How to use PHP7.0 to implement an API gateway with microservice architecture?

With the popularity of cloud computing and microservice architecture, API gateway is an indispensable part of the microservice system, and its functions are becoming more and more important. The API gateway can intercept and forward all requests in and out of the system, and is responsible for security, access control, traffic control, load balancing and other functions.

In this article, we will introduce how to use PHP7.0 to implement a simple API gateway to achieve the following functions:

• Routing: forward requests based on the requested URL and HTTP method to the corresponding microservice.
• Current limiting: Limit the frequency and number of concurrency of each API call.
• Authentication and authorization: Identify and verify the identity of the request, and control access based on the user's role and permissions.
• Statistics: Record and analyze API usage in order to identify potential bottlenecks.

Before you begin, please make sure you have the following software installed:

• PHP7.0 or higher.
• Composer: PHP package manager.
• Guzzle: PHP library for HTTP requests.
• Redis: An in-memory key-value database used to store Tokens and current limit counters.

Step 1: Write a basic API gateway

First, we need to create a basic API gateway for routing requests to microservices. We will use Symfony Routing Component to handle routing.

Create a new PHP file, for example index.php, and add the following code:

require_once 'vendor/autoload.php';

use SymfonyComponentRoutingRouteCollection;
use SymfonyComponentRoutingRoute;
use SymfonyComponentHttpFoundationRequest;
use SymfonyComponentHttpFoundationResponse;
use SymfonyComponentRoutingMatcherUrlMatcher;
use SymfonyComponentRoutingExceptionResourceNotFoundException;

$routes = new RouteCollection();

$routes->add('hello', new Route('/hello/{name}', array(
    'controller' => function ($request) {
        return new Response(sprintf("Hello, %s!", $request->attributes->get('name')));
    }
)));

$matcher = new UrlMatcher($routes, getRequest());

try {
    $request = Request::createFromGlobals();
    $parameters = $matcher->matchRequest($request);
    $response = call_user_func($parameters['controller'], $request);
} catch (ResourceNotFoundException $exception) {
    $response = new Response('Not Found', Response::HTTP_NOT_FOUND);
} catch (Exception $exception) {
    $response = new Response('An error occurred', Response::HTTP_INTERNAL_SERVER_ERROR);
}

$response->send();

In this code, we create a route called "hello" that will The request is forwarded to an anonymous controller method. When this route is processed, it will return "Hello, {name}!" in the response where {name} is the route parameter.

We use Symfony's Request and Response classes to create and send HTTP requests and responses. Symfony's Routing component is responsible for routing requests to matching routes and calling matching controller methods.

At this point, we can run this file and visit http://localhost:8080/hello/world, and we can see the output "Hello, world!".

Step 2: Add the current limiting function

We hope that the API gateway can limit each API request to reduce the risk of overload on the server side. To do this, we can use Redis to store throttling counters for each API.

First, we need to use Composer to install Predis, which is a Redis client library in PHP:

composer require predis/predis

Then, add the following code in index.php so that every time the microservice Check the counter before requesting:

use PredisClient;

// ...

$redis = new Client();

// Limit requests to 100 per minute per user.
$maxRequests = 100;
$timeWindow = 60; // seconds

$ip = $_SERVER['REMOTE_ADDR'];
$key = "ratelimit:{$ip}";

$currentRequests = $redis->incr($key);
$redis->expire($key, $timeWindow);

if ($currentRequests > $maxRequests) {
    $response = new Response('Rate limit exceeded', Response::HTTP_TOO_MANY_REQUESTS);
    $response->headers->set('Retry-After', $timeWindow);
    $response->send();
    exit;
}

In this code, we use the Predis client to connect to the Redis server and use the IP address of each request as the key name. We set a limit of 100 requests per minute per user and use the Incr function to increment the counter.

If the current value of the counter exceeds the maximum limit, an HTTP 429 "Too Many Requests" response is returned and the "Retry-After" header is set to notify the client when to try the request again.

Step 3: Add authentication and authorization functions

We also need to add basic authentication and authorization functions for each API request. For this we will use the JSON Web Token (JWT) standard.

To use JWT, please install the firebase/php-jwt library first:

composer require firebase/php-jwt

Then, add the following code in index.php to implement JWT standard authentication and authorization:

use FirebaseJWTJWT;

// ...

$key = 'secret';
$token = $_SERVER['HTTP_AUTHORIZATION'] ?? '';

if ($token) {
    try {
        $decoded = JWT::decode($token, $key, array('HS256'));
        $user_id = $decoded->sub;
        $roles = $decoded->roles;
    } catch (Exception $e) {
        $response = new Response('Invalid token', Response::HTTP_UNAUTHORIZED);
        $response->send();
        exit;
    }

    // Check user roles and permissions here...
} else {
    $response = new Response('Token required', Response::HTTP_UNAUTHORIZED);
    $response->send();
    exit;
}

In this code, we use the JWT token extracted from the HTTP header to identify and authenticate the request. We use the JWT library to decode the token and verify the signature and validity. If the token is valid, the user ID and role information are extracted from it and its permissions are checked. If the token is invalid, an HTTP 401 "Unauthorized" response is returned.

Step 4: Add statistics function

Finally, we add a simple statistics function to record API usage. To do this, we will use Redis to store metrics such as number of requests and response times.

First, we need to install the phpredis extension:

sudo apt-get install php7.0-redis

Then, add the following code in index.php to record the statistics of each request:

use PredisClient;

// ...

$redis = new Client();

$ip = $_SERVER['REMOTE_ADDR'];
$key = "stats:{$ip}";
$now = time();
$timestamp = strtotime(date('Y-m-d H:i:00', $now));

$redis->zincrby($key, 1, $timestamp);
$redis->expire($key, 3600);

Here In the code, we consider the number of requests per IP address (i.e. per user) and increase the value of the request counter by 1 using Redis's ZINCRBY command. We also use setting the expiration time in Redis to delete expired records.

Step 5: Deploy API Gateway

Now, we have added basic functions such as routing, restrictions, authentication, authorization, and statistics to our API gateway. We can deploy it using a traditional web server like Apache or Nginx, or use the PHP built-in server for testing.

First, run the following command in the terminal in order to start the PHP built-in server and point it to our index.php file:

php -S localhost:8080

Then, we can visit http:// in the browser /localhost:8080/, and add routes such as /hello/world in the URL path to test various functions of the API gateway.

Summary

In this article, we use PHP7.0 and various open source libraries to implement a basic API gateway, and add basic functions such as restrictions, authentication, authorization, and statistics. API gateway is an integral part of microservices architecture, which can help us achieve better performance, security and scalability.

In fact, there are now many powerful API gateway solutions to choose from, such as Kong, Tyk, AWS API Gateway, etc., which provide more advanced functions and integrations, such as load balancing, caching, security, monitoring and management etc.

However, it is still valuable to know how to build an API gateway using libraries such as PHP and Symfony, and it is an excellent choice when you need to quickly build a simple API gateway.

The above is the detailed content of How to use PHP7.0 to implement an API gateway with microservice architecture?. For more information, please follow other related articles on the PHP Chinese website!