What Does an API Gateway Do?

By /

Listen to this Post

An API gateway acts as a single entry point for clients, handling request routing, response composition, and protocol translation. It simplifies client interactions with microservices and offers additional features like rate limiting, authentication, monitoring, and more.

To better understand how an API gateway works, let’s look at how it processes a request:

1. Initial Request Handling:

Client requests are sent to the API gateway, which acts as the entry point for all incoming API traffic, rather than directly accessing the backend services.

2. Request Validation:

The API gateway processes and validates the request’s attributes to ensure it’s correctly formatted.

3. Security Checks:

It then performs checks against allow-lists and deny-lists to filter out unauthorized or harmful requests.

4. Authentication and Authorization:

The API gateway validates the request, checking for proper authentication (e.g., verifying tokens or credentials) and ensuring the client has the necessary permissions (authorization) to access the requested resources.

5. Rate Limiting:

Rate limiting rules are enforced; if the request exceeds the allowed limit, it’s rejected.

6. Service Discovery and Routing:

Once passing basic checks, the API gateway then finds the relevant service to route the request to by matching the path.

7. Protocol Translation:

The API gateway transforms the request into the appropriate protocol and sends it to the service.

8. Response Aggregation:

If the request requires data from multiple services, the API gateway aggregates the responses. It sends requests to each relevant service, collects the results, and composes them into a single, cohesive response.

9. Response Delivery:

The gateway sends the processed response back to the client, ensuring it’s delivered in the expected format and within an optimal timeframe.

10. Logging, Monitoring, Fault Handling, and Caching:

Throughout this process, the API gateway logs each request and response and monitors key metrics such as latency, error rates, and throughput. These logs and metrics help in troubleshooting, scaling, and optimizing the system. It also deals with faults (circuit break) and provides response caching.

Practice Verified Codes and Commands:

  • Rate Limiting with Nginx: 
    http {
limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s;</li>
</ul>

server {
location /api/ {
limit_req zone=one burst=5;
proxy_pass http://backend_service;
}
}
}
    • Authentication with JWT in Node.js:
      [javascript]
      const jwt = require(‘jsonwebtoken’);
      const express = require(‘express’);
      const app = express();

    app.use(express.json());

    app.post(‘/login’, (req, res) => {
    const user = { id: 1, username: ‘test’ };
    const token = jwt.sign(user, ‘secret_key’, { expiresIn: ‘1h’ });
    res.json({ token });
    });

    app.get(‘/protected’, (req, res) => {
    const token = req.headers[‘authorization’];
    if (!token) return res.status(401).send(‘Access Denied’);

    jwt.verify(token, ‘secret_key’, (err, user) => {
    if (err) return res.status(403).send(‘Invalid Token’);
    res.json({ message: ‘Protected Route’, user });
    });
    });

    app.listen(3000, () => console.log(‘Server running on port 3000’));
    [/javascript]

    • Service Discovery with Consul: 
      consul agent -dev
consul services register -name=api-service -address=127.0.0.1 -port=8080
consul catalog services

    • Protocol Translation with Envoy Proxy: 

      static_resources:
listeners:</p></li>
<li>name: listener_0
address:
socket_address:
address: 0.0.0.0
port_value: 8080
filter_chains:</li>
<li>filters:</li>
<li>name: envoy.http_connection_manager
config:
stat_prefix: ingress_http
route_config:
name: local_route
virtual_hosts:</li>
<li>name: backend
domains: ["*"]
routes:</li>
<li>match:
prefix: "/"
route:
cluster: backend_service
http_filters:</li>
<li>name: envoy.router
clusters:</li>
<li>name: backend_service
connect_timeout: 0.25s
type: strict_dns
lb_policy: round_robin
hosts:</li>
<li>socket_address:
address: backend
port_value: 80

    What Undercode Say:

    API gateways are essential in modern microservices architectures, acting as the central hub for managing, securing, and optimizing API traffic. They handle critical tasks such as request validation, authentication, rate limiting, and protocol translation, ensuring seamless communication between clients and backend services. By aggregating responses from multiple services, they simplify client-side logic and improve performance. Additionally, API gateways provide robust monitoring and logging capabilities, enabling teams to troubleshoot issues, scale systems, and optimize performance effectively.

    To further enhance your understanding, here are some Linux and Windows commands related to API management and microservices:

    • Linux Commands:
    • Use `curl` to test API endpoints: 
      curl -X GET http://localhost:8080/api/resource
    • Monitor API traffic with netstat: 
      netstat -tuln | grep :8080
    • Check logs for API gateway errors: 
      tail -f /var/log/nginx/error.log

    • Windows Commands:

    • Test API endpoints using Invoke-WebRequest: 
      Invoke-WebRequest -Uri http://localhost:8080/api/resource -Method GET
    • Monitor network activity with netstat: 
      netstat -an | find "8080"
    • Check event logs for API-related errors: 
      Get-EventLog -LogName Application -Source "API Gateway"

    For more advanced API gateway configurations, consider exploring tools like Kong, Traefik, or AWS API Gateway. These platforms offer extensive features for managing API traffic, including load balancing, caching, and security enhancements.

    Further Reading:

    References:

    Hackers Feeds, Undercode AIFeatured Image

Related Posts: