Microservices in PHP: Architecture and Practice

Microservices in PHP: Architecture and Practice

In modern web development, monolithic architecture is increasingly giving way to microservices. PHP, traditionally associated with monoliths (WordPress, Laravel monolith), is well-suited for building distributed systems. In this article, we will break down the key principles of microservice architecture in PHP, look at practical code examples, and tools that will help you transition from a monolith to a flexible system.

What are microservices and why are they needed in PHP

Microservice architecture is an approach where an application is divided into several independent services. Each service is responsible for its own business logic (authentication, payments, notifications) and can be developed, deployed, and scaled separately.

Why PHP is suitable for microservices:

• Quick start — PHP frameworks (Laravel, Symfony, Lumen) allow you to create a service in minutes.
• Large community — thousands of ready-made packages for working with queues, APIs, and databases.
• Flexibility — you can combine PHP with other languages (Go, Python) in one system.

However, remember: microservices add complexity. You should not split a project if you have a small application. Start with a monolith, then extract services as it grows.

Architecture of a typical microservice in PHP

Let's look at the basic structure of one service. Suppose we have a UserService responsible for user registration and authorization.

Project structure:

user-service/├── api/│   └── index.php          # entry point (REST API)├── src/│   ├── Controllers/│   │   └── AuthController.php│   ├── Models/│   │   └── User.php│   ├── Services/│   │   └── AuthService.php│   └── Database/│       └── migrations/├── config/│   └── database.php├── composer.json├── Dockerfile└── .env

Each service:

• Has its own repository and database (often PostgreSQL or MySQL).
• Communicates with the outside world via REST API or gRPC.
• Is packaged in a Docker container.

Example of a simple REST controller in Lumen (Laravel micro-framework):

<?php

namespace App\\Http\\Controllers;

use Illuminate\\Http\\Request;use App\\Models\\User;

class AuthController extends Controller{    public function register(Request $request)    {        // Validation        $this->validate($request, [            'email' => 'required|email|unique:users',            'password' => 'required|min:8'        ]);

        // Create user        $user = User::create([            'email' => $request->input('email'),            'password' => app('hash')->make($request->input('password'))        ]);

        return response()->json(['user_id' => $user->id], 201);    }}

Data exchange between services: synchronous and asynchronous

Microservices cannot exist in isolation. There are two main ways of communication:

1. Synchronous (HTTP/REST)

Service A directly calls the API of service B. Simple, but creates tight coupling.

<?php// In OrderService$httpClient = new \\GuzzleHttp\\Client();$response = $httpClient->post('http://user-service/api/validate', [    'json' => ['token' => $token]]);

if ($response->getStatusCode() === 200) {    // User is valid}

2. Asynchronous (queues / RabbitMQ)

The service sends a message to a broker (RabbitMQ, Kafka), and another service processes it in the background. This reduces load and makes the system more fault-tolerant.

Example of sending an event via RabbitMQ using the php-amqplib library:

<?phprequire_once __DIR__ . '/ve