Microservices in PHP: Architecture and Practice from A to Z

Introduction: Why PHP and Microservices?

For a long time, PHP was associated exclusively with monolithic applications — WordPress, Laravel, or Symfony. However, modern PHP (starting from version 7.4 and especially 8.x) has evolved into a powerful tool for building microservice architecture. Thanks to improved performance, strict typing, asynchronous capabilities (via ReactPHP or Swoole), and a mature ecosystem, PHP has become a full-fledged language for microservices.

In this article, we will cover: what microservices in PHP are, how to design the architecture, which technologies to use, and write real code examples.

What is Microservice Architecture?

Microservices are an approach where an application is broken down into small, independently deployable services. Each service is responsible for its own business function and communicates with others over the network (HTTP/REST, gRPC, message queues).

Key Principles of Microservices in PHP

• Independence — each service can be written in PHP, Node.js, or Go, but we use PHP for all.
• Data Decentralization — each database belongs to only one service.
• Orchestration vs Choreography — choosing between central management (Kubernetes) and an event-driven approach.
• Fault Tolerance — one failed service should not break the entire system.

Microservice Architecture in PHP: From Theory to Practice

Consider a typical project: an online store. Let's break it down into microservices:

• User Service — registration, authentication, profiles.
• Product Service — product catalog, prices, stock.
• Order Service — order creation, statuses.
• Payment Service — payment processing.
• Notification Service — email/SMS notifications.

Step 1: Designing the API Gateway

API Gateway — a single entry point. In PHP, it can be implemented using Slim Framework or with Nginx + PHP-FPM. Example of a simple gateway on Slim 4:

<?php// api-gateway/public/index.phpuse Slim\\Factory\\AppFactory;use Psr\\Http\\Message\\ServerRequestInterface as Request;use Psr\\Http\\Message\\ResponseInterface as Response;

require __DIR__ . '/../vendor/autoload.php';

$app = AppFactory::create();

// Routing to microservices$app->post('/api/orders', function (Request $request, Response $response) {    // Forward the request to Order Service    $client = new GuzzleHttp\\Client(['base_uri' => 'http://order-service:8080']);    $res = $client->post('/orders', [        'json' => $request->getParsedBody()    ]);    $response->getBody()->write($res->getBody());    return $response->withStatus($res->getStatusCode());});

$app->run();

Step 2: Synchronous Interaction (REST)

The simplest way is HTTP requests between services. Use Guzzle or Symfony HttpClient. Example of Product Service:

<?php// product-service/src/Controller/ProductController.phpnamespace App\\Controller;

use Symfony\\Component\\HttpFoundation\\JsonResponse;use Symfony\\Component\\HttpFoundation\\Request;

class ProductController{    public function getProduct(int $id): JsonResponse    {        // Logic for retrieving product from DB        $product = $this->productRepository->find($id);                if (!$product) {            return new JsonResponse(['error' => 'Product not found'], 404);        }                return new JsonResponse([            'id' => $product->getId(),            'name' => $product->getName(),            'price' => $product->getPrice()        ]);    }}

Step 3: Asynchro