CODEWITHSUNDEEP
ruby-on-railsrestapimicroservices
Gleb
Gleb

Reputation: 93

How to organize delayed results processing in microservices communication?

I have the following system: my Rails server issues commands to the Flask server and the latest one responses immediately with status 200. After that Flask server runs a background task with some time-consuming function. After a little while, it comes up with some results and designed to send data back to the Rails server via HTTP (see diagram) enter image description here

Each Flask data portion can affect several Rails models (User, Post etc...). Here I faced with two questions:

  1. How I should structure my controllers/actions on the Rails side in this case? Currently, I think about one controller and each action of it corresponds to Python 'delayed' data portion.
  2. Is it a normal way of microservices communication? Or I can organize it in a different, more simple way?

Upvotes: 0

Views: 58

Answers (1)

max
max

Reputation: 102240

This sounds like pretty much your standard webhook process. Rails pokes Flask with a GET or POST request and Flask pokes back after a while.

For example lets say we have reports, and after creating the report we need flask to verify the report:

class ReportsController
  # POST /reports
  def create
    @report = Report.new(report_params)
    if @report.save
      FlaskClient.new.verify(report) # this could be delegated to a background job
      redirect_to @report
    else
      render :new
    end
  end

  # PATCH /reports/:id/verify
  def verify
    # process request from flask
  end
end

class FlaskClient
  include Httparty

  base_uri 'example.com/api'
  format 'json'

  def verify(report)
    self.class.post('/somepath', data: { id: report.id, callback_url: "/reports/#{report.id}/verify", ... })
  end
end

Of course the Rails app does not actually know when Flask will respond or that Flask and the background service are different. It just sends and responds to http requests. And you definitely don't want rails to wait around so save what you have and then later the hook can update the data.

If you have to update the UI on the Rails side without the user having to refresh manually you can use polling or websockets in the form of ActionCable.

Upvotes: 1

Related Questions