In this article, we are going to use Zato in its capacity as a multi-protocol Python API gateway – we will integrate a few popular technologies, accepting requests sent over protocols commonly used in frontend systems, enriching and passing them to backend systems, and returning responses to the API clients using their preferred data formats. But first, let’s define what an API gateway is.

Clearing up the Terminology

Although we will be focusing on complex API integrations later, to understand the term API gateway we first need to give proper consideration to the very term gateway.

What comes to mind when we hear the word “gateway,” and what is correct etymologically indeed, is an opening in an otherwise impermissible barrier. We use a gateway to access that which is in other circumstances inaccessible for various reasons. We use it to leave such a place too.

In fact, both “gate” and the verb “to go” stem from the same basic root, and that, again, brings to mind a notion of passing through space specifically set aside for the purpose of granting access to what normally would be unavailable. And, once more, when we depart from such an area, we use a gateway too.

From the perspective of its true intended purpose, a gateway letting everyone in and out as they are would amount to little more than a hole in a wall. In other words, a gateway without a gate is not the whole story.

Yes, there is undoubtedly an immense aesthetic gratification to be drawn from being close to marvels of architecture that virtually all medieval or Renaissance gates and gateways represent, but we know that, contemporarily, they do not function to the fullest of their capacities as originally intended.

Rather, we can intuitively say that a gateway is in service as a means of entry and departure if it lets its operators achieve the following, though not necessarily all at the same time, depending on one’s particular needs:

  • Telling arrivals where they are, including projection of might and self-confidence.
  • Confirming that arrivals are who they say they are.
  • Checking if their port of origin is friendly or not.
  • Checking if they are allowed to enter that which is protected.
  • Directing them to specific areas behind the gateway.
  • Keeping a long term and short term log of arrivals.
  • Answering potential questions right by the gate, if answers are known to gatekeepers.
  • Cooperating with translators and coordinators that let arrivals make use of what is required during their stay.

We can now recognize that a gateway operates on the border of what is internal and external and in itself, it is a relatively narrow, though possibly deep, piece of architecture. It is narrow because it is only through the gateway that entry is possible but it may be deeper or not, depending on how much it should offer to arrivals.

We also keep in mind that there may very well be more than a single gateway in existence at a time, each potentially dedicated to different purposes, some overlapping, some not.

Finally, it is crucial to remember that gateways are structural, architectural elements – what a gateway should do and how it should do it is a decision left to architects.

With all of that in mind, it is easy to transfer our understanding of what a physical gateway is into what an API one should be.

  • API clients should be presented with clear information that they are entering a restricted area.
  • Source IP addresses or their equivalents should be checked and requests rejected if an IP address or equivalent information is not among the allowed ones.
  • Usernames, passwords, API keys, and similar representations of what they are should be checked by the gateway.
  • Permissions to access backend systems should be checked to see as not every API client should have access to everything.
  • Requests should be dispatched to relevant backend systems.
  • Requests and responses should be logged in various formats, some meant to be read by programs and applications, some by human operators.
  • If applicable, responses can be served from the gateway’s cache, taking the burden off the shoulders of the backend systems.
  • Requests and responses can be transformed or enriched which potentially means contacting multiple backend systems before an API caller receives a response.

We can now define an API gateway as an element of a systems architecture that is certainly related to security, permissions, and granting or rejecting access to backend systems, applications, and data sources. On top of it, it may provide audit, data transformation, and caching services. The definition will be always fluid to a degree, depending on an architect’s vision, but this is what can be expected from it nevertheless.

Having defined what an API gateway is, let’s create one in Zato and Python.

Clients and Backend Systems

In this article, we will integrate two frontend systems and one backend application. Frontend ones will use REST and WebSockets, whereas the backend ones will use AMQP. Zato will act as an API gateway between them all.

Zato as a Python API gateway architecture.

Not granting frontend API clients direct access to backend systems is usually a good idea because the dynamics involved in the creation of systems on either side are typically very different. But, they still need to communicate and hence the usage of Zato as an API gateway.

Python Code

First, let’s show the Python code that is needed to integrate the systems into our architecture.

# -*- coding: utf-8 -*-

# Zato
from zato.server.service import Service

class APIGateway(Service):    
    """ Dispatches requests to backend systems, enriching them along the way.   
    """    
    name = 'api.gateway'

    def handle(self):

        # Enrich incoming request with metadata ..
        self.request.payload['_receiver'] = self.name        
        self.request.payload['_correlation_id'] = self.cid        
        self.request.payload['_date_received'] = self.time.utcnow()

        # .. AMQP configuration ..
        outconn = 'My Backend'        
        exchange = '/incoming'       
        routing_key = 'api'

        # .. publish the message to an AMQP broker ..
        self.out.amqp.send(data, outconn, exchange, routing_key)

        # .. and return a response to our API client.
        self.response.payload = {'result': 'OK, data accepted'}

There are a couple of points of interest including:

  • The gateway service enriches incoming requests with metadata but it could very well enrich it with business data too, e.g. it could communicate with yet another system to obtain required information and only then pass the request to the final backend system(s).
  • In its current form, we send all the information to AMQP brokers only but we could just as well send it to other systems, possibly modifying the requests along the way.
  • The code is very abstract and all of its current configurations could be moved to a config file, Redis, or another data source to make it even more high-level.
  • Security configuration and other details are not declared directly in the body of the gateway service but they need to exist somewhere – we will describe it in the next section.

Configuration 

In Zato, API clients access the platform’s services using channels. Let’s create a channel for REST and WebSockets then.

First, REST:

REST screenshot.

Now, WebSockets:

Websocket screenshot.

We create a new outgoing AMQP connection in the same way as so:

Outgoing AMQP connection screenshot.

Using the API Gateway

At this point, the gateway is ready; you can invoke it from REST or WebSockets, and any JSON data it receives will be processed by the gateway service, the AMQP broker will receive it, and API clients will have replies from the gateway as JSON responses.

Let’s use curl to invoke the REST channel with JSON payload on input.

  $ curl http://api:<password-here>@localhost:11223/api/v1/user ; echo  
  curl --data-binary @request.json http://localhost:11223/api/v1/user ; echo  
  {"result": "OK, data accepted"}  
  $

Taken together, the channels and the service allowed us to achieve the following:

  • Multiple API clients can access the backend AMQP systems, each client using its own preferred technology.
  • Client credentials are checked on input before the service starts to process requests (authentication).
  • It is possible to assign RBAC roles to clients, in this way ensuring they have access only to selected parts of the backend API (authorization).
  • Message logs keep track of data incoming and outgoing.
  • Responses from channels can be cached which lessens the burden put on the shoulders of backend systems.
  • Services accepting requests are free to modify, enrich, and transform the data in any way required by business logic. E.g., in the code above we only add metadata but we could as well reach out to other applications before requests are sent to the intended recipients.

We can take it further. For instance, the gateway service is currently completely oblivious to the actual content of the requests.

But, since we just have a regular Python dict in self.request.payload, we can with no effort modify the service to dispatch requests to different backend systems, depending on what the request contains, or possibly what other backend systems decide the destination should be.

Such additional logic is specific to each environment or project which is why it is not shown here, and this is also why we end the article at this point, but the central part of it all is already done. The rest is only a matter of customization and plugging in more channels for API clients or outgoing connections for backend systems.

Finally, it is perfectly fine to split access to systems among multiple gateways; each may handle requests from selected technologies on the one hand, but on the other hand, each may use different caching or rate-limiting policies. If there is more than one, it may be easier to configure such details on a per-gateway basis.

Learn More

If you are interested in building scalable and reusable API systems, you can start now by visiting the Zato main page, familiarizing yourself with the extensive documentation, or by going straight to the first part of the tutorial.

Be sure to visit our Twitter, GitHub, and Gitter communities too!





Source link

Write A Comment