PHP微服务架构实战：基于gRPC与Docker的分布式系统构建指南 | 现代PHP开发教程

核心服务组件

• 用户服务：身份认证与权限管理
• 订单服务：交易流程处理
• 商品服务：商品信息管理
• 支付服务：第三方支付集成
• 通知服务：消息推送与邮件

基础设施层

• gRPC服务发现与通信
• Docker容器化部署
• Redis分布式缓存
• MySQL分库分表
• ELK日志收集系统

// protos/user_service.proto
syntax = "proto3";

package user;

service UserService {
    rpc GetUser (GetUserRequest) returns (UserResponse);
    rpc CreateUser (CreateUserRequest) returns (UserResponse);
    rpc UpdateUser (UpdateUserRequest) returns (UserResponse);
    rpc Authenticate (AuthRequest) returns (AuthResponse);
}

message GetUserRequest {
    string user_id = 1;
}

message CreateUserRequest {
    string username = 1;
    string email = 2;
    string password = 3;
    map<string, string> metadata = 4;
}

message UserResponse {
    string user_id = 1;
    string username = 2;
    string email = 3;
    int64 created_at = 4;
    int64 updated_at = 5;
    UserStatus status = 6;
}

enum UserStatus {
    ACTIVE = 0;
    INACTIVE = 1;
    SUSPENDED = 2;
}

# 生成PHP gRPC客户端和服务端代码
protoc --php_out=./generated 
       --grpc_out=./generated 
       --plugin=protoc-gen-grpc=/usr/local/bin/grpc_php_plugin 
       ./protos/*.proto

# 生成的目录结构
generated/
├── User/
│   ├── UserServiceClient.php
│   └── UserResponse.php
└── GPBMetadata/
    └── UserService.php

<?php

namespace ServicesUser;

use UserUserService;
use UserGetUserRequest;
use UserUserResponse;
use UserUserStatus;
use SpiralRoadRunnerGRPCServer;
use SpiralRoadRunnerWorker;

class UserServiceImpl extends UserService
{
    private PDO $db;
    private Redis $redis;
    
    public function __construct()
    {
        $this->db = new PDO(
            'mysql:host=mysql;dbname=user_db',
            'root',
            'password',
            [PDO::ATTR_PERSISTENT => true]
        );
        
        $this->redis = new Redis();
        $this->redis->connect('redis', 6379);
    }
    
    public function GetUser(
        GrpcServerContext $context,
        GetUserRequest $request
    ): UserResponse {
        $userId = $request->getUserId();
        
        // 尝试从缓存获取
        $cacheKey = "user:{$userId}";
        $cached = $this->redis->get($cacheKey);
        
        if ($cached) {
            $userData = json_decode($cached, true);
            return $this->createUserResponse($userData);
        }
        
        // 数据库查询
        $stmt = $this->db->prepare(
            "SELECT * FROM users WHERE id = ? AND status = 'active'"
        );
        $stmt->execute([$userId]);
        $userData = $stmt->fetch(PDO::FETCH_ASSOC);
        
        if (!$userData) {
            throw new GrpcStatusException(
                GrpcSTATUS_NOT_FOUND,
                "User not found"
            );
        }
        
        // 缓存用户数据
        $this->redis->setex($cacheKey, 3600, json_encode($userData));
        
        return $this->createUserResponse($userData);
    }
    
    private function createUserResponse(array $data): UserResponse
    {
        $response = new UserResponse();
        $response->setUserId($data['id']);
        $response->setUsername($data['username']);
        $response->setEmail($data['email']);
        $response->setCreatedAt(strtotime($data['created_at']));
        $response->setUpdatedAt(strtotime($data['updated_at']));
        $response->setStatus(
            UserStatus::value($data['status'] ?? 'ACTIVE')
        );
        
        return $response;
    }
    
    public function startServer(): void
    {
        $worker = Worker::create();
        $server = new Server();
        
        $server->registerService(UserService::class, new self());
        
        $server->serve($worker);
    }
}

<?php

namespace ClientGrpc;

class ServiceClient
{
    private array $services = [];
    private array $channels = [];
    
    public function __construct(array $config)
    {
        foreach ($config as $serviceName => $serviceConfig) {
            $this->channels[$serviceName] = new GrpcChannel(
                $serviceConfig['host'],
                [
                    'credentials' => GrpcChannelCredentials::createInsecure(),
                    'timeout' => $serviceConfig['timeout'] ?? 5000,
                ]
            );
        }
    }
    
    public function getUserService(): UserUserServiceClient
    {
        if (!isset($this->services['user'])) {
            $this->services['user'] = new UserUserServiceClient(
                'user-service:50051',
                [
                    'credentials' => GrpcChannelCredentials::createInsecure(),
                ]
            );
        }
        
        return $this->services['user'];
    }
    
    public function callWithRetry(
        string $service,
        string $method,
        $request,
        int $maxRetries = 3
    ) {
        $retryCount = 0;
        $lastException = null;
        
        while ($retryCount getServiceClient($service);
                return $client->$method($request);
            } catch (GrpcStatusException $e) {
                $lastException = $e;
                
                // 可重试的错误码
                $retryCodes = [
                    GrpcSTATUS_UNAVAILABLE,
                    GrpcSTATUS_DEADLINE_EXCEEDED,
                ];
                
                if (!in_array($e->getCode(), $retryCodes)) {
                    break;
                }
                
                $retryCount++;
                usleep(100000 * $retryCount); // 指数退避
            }
        }
        
        throw $lastException;
    }
}

<?php

namespace ServicesOrder;

use UserGetUserRequest;

class OrderService
{
    private ClientGrpcServiceClient $grpcClient;
    
    public function createOrder(array $orderData): array
    {
        // 验证用户是否存在
        $userRequest = new GetUserRequest();
        $userRequest->setUserId($orderData['user_id']);
        
        try {
            $userResponse = $this->grpcClient->callWithRetry(
                'user',
                'GetUser',
                $userRequest
            );
            
            // 用户验证通过，创建订单
            $order = $this->saveOrder($orderData);
            
            // 异步调用支付服务
            $this->initiatePayment($order);
            
            // 异步发送通知
            $this->sendOrderNotification($order, $userResponse);
            
            return [
                'success' => true,
                'order_id' => $order['id'],
                'user' => [
                    'id' => $userResponse->getUserId(),
                    'email' => $userResponse->getEmail(),
                ]
            ];
            
        } catch (GrpcStatusException $e) {
            return [
                'success' => false,
                'error' => 'User validation failed: ' . $e->getMessage(),
            ];
        }
    }
    
    private function saveOrder(array $data): array
    {
        // 订单保存逻辑
        $orderId = uniqid('order_');
        
        return [
            'id' => $orderId,
            'user_id' => $data['user_id'],
            'amount' => $data['amount'],
            'items' => $data['items'],
            'created_at' => time(),
        ];
    }
}

用户服务Dockerfile

FROM php:8.2-cli

# 安装系统依赖
RUN apt-get update && apt-get install -y 
    git 
    unzip 
    libzip-dev 
    libpq-dev 
    && docker-php-ext-install zip pdo pdo_mysql

# 安装Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# 安装gRPC扩展
RUN pecl install grpc protobuf 
    && docker-php-ext-enable grpc protobuf

# 复制应用代码
WORKDIR /app
COPY . .

# 安装PHP依赖
RUN composer install --no-dev --optimize-autoloader

# 运行RoadRunner
CMD ["php", "vendor/bin/rr", "serve", "-c", "/app/.rr.yaml"]

RoadRunner配置

# .rr.yaml
version: '3'

server:
  command: "php user-server.php"
  relay: "tcp://127.0.0.1:7000"

grpc:
  listen: "tcp://0.0.0.0:50051"
  proto:
    - "protos/user_service.proto"

logs:
  level: debug
  mode: production

metrics:
  address: 0.0.0.0:2112

服务发现与负载均衡

// 使用Consul进行服务发现
$consul = new ConsulClient();
$services = $consul->catalog->service('user-service');

// 随机选择一个健康实例
$healthy = array_filter($services, fn($s) => $s['Status'] === 'passing');
$selected = $healthy[array_rand($healthy)];

分布式追踪

// 集成Jaeger分布式追踪
$tracer = GlobalTracer::get();
$span = $tracer->startSpan('CreateOrder');

// 传递追踪上下文
$carrier = [];
$tracer->inject($span->getContext(), 
    FormatTEXT_MAP, $carrier);

// 在gRPC metadata中传递
$metadata = ['trace-context' => 
    json_encode($carrier)];

熔断与降级

// 使用PHP熔断器模式
$circuitBreaker = new CircuitBreaker(
    maxFailures: 5,
    timeout: 30,
    fallback: function() {
        return ['status' => 'degraded'];
    }
);

return $circuitBreaker->call(function() {
    return $this->grpcClient->getUser($userId);
});

性能指标

• QPS: 10,000+
• 延迟: < 50ms
• 吞吐量: 1GB/s

监控工具

• Prometheus + Grafana
• Jaeger分布式追踪
• ELK日志分析

压测工具

• ghz (gRPC压测)
• Apache Bench
• k6

初级阶段

• 2-3个核心服务
• 基础服务发现
• 简单负载均衡
• 基础监控告警

中级阶段

• 服务网格集成
• 自动化部署流水线
• 分布式追踪系统
• 多环境部署策略

高级阶段

• 服务网格治理
• 混沌工程实践
• 智能弹性伸缩
• 多云部署架构