PHP et Lumen s'intègrent pour réaliser le développement d'une architecture de microservices

Avec le développement rapide de la technologie informatique, les entreprises modernes sont confrontées à des systèmes d'entreprise de plus en plus complexes. L'architecture traditionnelle à application unique ne peut plus répondre aux besoins, et l'architecture des microservices a émergé au fur et à mesure que le temps l'exige. L'architecture des microservices est un style architectural dans lequel les applications sont composées de plusieurs petits services qui peuvent être déployés, exécutés, étendus et maintenus indépendamment pour obtenir une meilleure évolutivité, réutilisation et flexibilité.

Alors, comment utiliser PHP pour implémenter une architecture de microservices ? La réponse est d'utiliser Lumen - un framework PHP léger. Basé sur Laravel, Lumen est un framework PHP conçu pour créer des microservices et des API. Cet article expliquera comment intégrer l'architecture de microservices dans le framework Lumen.

Première étape : installer Lumen

Tout d'abord, nous devons installer le framework Lumen localement. Les étapes d'installation sont les mêmes que pour Laravel. Il peut être installé via Composer, comme indiqué ci-dessous :

composer create-project --prefer-dist laravel/lumen lumen_api

Une fois terminé, nous pouvons démarrer l'environnement d'exécution du framework Lumen localement :

php -S localhost:8000 -t public

Quand "Le serveur de développement Lumen a démarré : < ;http://localhost:8000>", cela signifie que le framework Lumen a déployé avec succès l'environnement d'exécution local et que nous pouvons accéder à sa page par défaut via http://localhost:8000.

Étape 2 : Écrire des microservices

Ensuite, nous utiliserons le framework Lumen pour écrire notre premier microservice. Nous allons créer une API simple qui obtient une liste de tous les utilisateurs. Les étapes pour implémenter cette API sont les suivantes :

1. Créer une route API

Dans le fichier de routage routes/web.php, nous devons écrivez une route pour gérer les requêtes vers l'API. Dans cet exemple, nous allons écrire une route GET dans le fichier de route pour gérer les requêtes /get_users, comme indiqué ci-dessous :

$router->get('/get_users', function () use ($router) {
    return 'List of all users';
});

À ce stade, lorsque vous demanderez http://localhost:8000/ get_users renvoie la chaîne "Liste de tous les utilisateurs".

2. Gestion des requêtes API

Maintenant, nous devons créer une classe de contrôleur pour notre API. Créons la classe UserController qui sera chargée de gérer la requête get_users et de renvoyer la liste des utilisateurs. Nous pouvons créer le fichier UserController.php dans le répertoire app/Http/Controllers et y copier le code suivant :

<?php

namespace AppHttpControllers;

use IlluminateHttpRequest;

class UserController extends Controller
{
    public function getAllUsers()
    {
        $users = ['User 1', 'User 2', 'User 3'];
        return response()->json($users);
    }
}

Dans le code ci-dessus, nous définissons une fonction publique getAllUsers(), qui La fonction renverra une liste de tous les utilisateurs en réponse au format JSON.

3. Enregistrer le routage API vers le contrôleur

Maintenant, nous devons enregistrer le routage API vers le contrôleur UserController dans le fichier de routage, ajouter notre route / api/get_users est mappé à la méthode UserController@getAllUsers, et le fichier de route est modifié comme suit :

$router->get('api/get_users', 'UserController@getAllUsers');

À ce moment, lorsque vous demandez http://localhost:8000/api/get_users, un JSON sera renvoyé La liste des utilisateurs au format, comme indiqué ci-dessous :

{
    "0": "User 1",
    "1": "User 2",
    "2": "User 3"
}

Enfin, nous devons également importer la classe UserController en haut, comme indiqué ci-dessous :

<?php

use AppHttpControllersUserController;

#🎜 🎜#De cette façon, nous avons implémenté avec succès une API de base qui peut fonctionner sous le framework Lumen.

Étape 3 : Intégrer le framework de microservices

Avant cela, nous avons créé notre première API dans le framework Lumen, mais ce n'est pas vraiment une application de service de framework de microservices. Afin de transformer Lumen en une application d'architecture de microservices, nous devons utiliser les idées de conception de modèles de domaine DDD pour reconstruire notre application. Ensuite, nous utiliserons l'idée de microservices pour décomposer chacun de nos services en microservices.

Domain Design

Tout d'abord, nous devons définir notre modèle de domaine, qui est le cœur de notre application. Dans cet exemple, nous allons créer un microservice simple de gestion des utilisateurs dont la fonction principale est de gérer les données des utilisateurs.

Notre microservice de gestion des utilisateurs doit avoir les fonctions suivantes :

Inscription des utilisateurs
Authentification des utilisateurs
• #🎜🎜 # UserAuthorization
• User Information Management
Maintenant, nous devons mapper ces fonctions à l'interface du microservice.

Interface microservice

Nous concevrons différentes interfaces de microservice en fonction des différentes fonctions du modèle de domaine. Nous allons définir ici l'interface de microservice suivante :

Interface d'enregistrement utilisateur (registerUser)

• Interface d'authentification utilisateur (authenticateUser)
• User Autoriser l'utilisateur #Maintenant, nous devons diviser notre interface de microservice en différents modules de microservice. Dans cet exemple, nous utiliserons les trois modules de microservice suivants :
Microservice d'authentification et d'autorisation des utilisateurs
Microservice de gestion des informations utilisateur

microservice d'enregistrement des utilisateurs

Ces modules de microservice interagiront directement avec notre base de données.

Architecture microservice
• Nous avons maintenant notre modèle de domaine, notre interface microservice et nos composants de module microservice, nous pouvons maintenant simplement les combiner dans une architecture microservices . L'architecture entière ressemble à ceci :

API Gateway (Lumen) <--> User Authentication and Authorization Microservice <--> User Information Management Microservice <--> User Registration Microservice

• Nous activons la passerelle API Lumen, qui est le point initial de notre système et recevra toutes les demandes et les acheminera vers le module de microservice approprié. Notre modèle de domaine est notre logique métier et l'interface du microservice contrôlera nos interactions avec les données.

第四步：实现微服务

现在，我们已经设计了微服务模块、微服务接口和整体微服务架构，我们可以开始实现我们的微服务。我们将针对上述三个微服务模块分别进行介绍。

1. 用户认证与授权微服务

我们的用户认证与授权微服务负责处理所有与用户认证相关的任务。它将接收用户凭据并验证它们的凭证是否正确。如果验证成功，它将生成一个JWT标记并将其返回给用户。

我们将针对以下任务编写用户认证与授权微服务:

• 为用户生成JWT标记
• 验证用户凭据

我们可以通过安装tymon / jwt-auth组件来编写我们的用户认证与授权微服务。使用以下命令进行安装：

composer require tymon/jwt-auth

然后，我们需要在配置文件中配置JWT密钥。现在，我们可以使用以下代码为用户认证与授权微服务创建一个新控制器：

<?php

namespace AppHttpControllers;

use IlluminateSupportFacadesAuth;
use AppModelsUser;
use IlluminateHttpRequest;

class AuthController extends Controller
{
    /**
     * Create a new AuthController instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('auth:api', ['except' => ['login']]);
    }
  
    /**
     * Get a JWT token.
     *
     * @return void
     */
    public function login(Request $request)
    {
        $credentials = $request->only('email', 'password');
        if ($token = $this->guard()->attempt($credentials)) {
            return $this->respondWithToken($token);
        }
        return response()->json(['error' => 'Unauthorized'], 401);
    }
  
    /**
     * Get the authenticated User.
     *
     * @return void
     */
    public function me()
    {
        return response()->json(auth()->user());
    }
  
    /**
     * Log the user out (Invalidate the token).
     *
     * @return void
     */
    public function logout()
    {
        auth()->logout();
        return response()->json(['message' => 'Successfully logged out']);
    }
  
    /**
     * Refresh a token.
     *
     * @return void
     */
    public function refresh()
    {
        return $this->respondWithToken(auth()->refresh());
    }
  
    /**
     * Get the token array structure.
     *
     * @param  string $token
     *
     * @return mixed
     */
    protected function respondWithToken($token)
    {
        return response()->json([
            'access_token' => $token,
            'token_type' => 'bearer',
            'expires_in' => auth()->factory()->getTTL() * 60
        ]);
    }
  
    /**
     * Get the guard to be used during authentication.
     *
     * @return IlluminateContractsAuthGuard
     */
    public function guard()
    {
        return Auth::guard();
    }
}

2. 用户信息管理微服务

用户信息管理微服务将负责向用户提供用户相关信息。在本例中，我们将创建以下操作的API：

• 获取用户个人信息
• 更新用户密码

首先，我们将创建一个新控制器来管理用户信息：

<?php

namespace AppHttpControllers;

use IlluminateSupportFacadesHash;
use AppModelsUser;
use IlluminateHttpRequest;

class UserController extends Controller
{
    public function getUser(Request $request)
    {
        $user = User::where('id', $request->id)->first();
        if (!$user) {
            return response()->json(['message' => 'User not found.'], 404);
        }
        return response()->json(['user' => $user]);
    }
  
    public function updateUserPassword(Request $request)
    {
        $user = User::where('id', $request->id)->first();
        if (!$user) {
            return response()->json(['message' => 'User not found.'], 404);
        }
        $user->password = Hash::make($request->password);
        $user->save();
        return response()->json(['message' => 'User password updated successfully.']);
    }
  
}

3. 用户注册微服务

注册微服务将处理用户注册过程。在本例中，我们将创建以下功能：

• 创建一个新用户，保存到数据库中
• 发送电子邮件以验证用户的电子邮件地址

首先，我们将创建一个新控制器来处理用户注册。它应该读取POST有效载荷并保存新用户到数据库中。然后，它应该生成用户验证令牌并将其发送到用户的电子邮件地址。

<?php

namespace AppHttpControllers;

use IlluminateSupportFacadesHash;
use AppModelsUser;
use IlluminateHttpRequest;

class RegisterController extends Controller
{
    public function create(Request $request)
    {
        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => Hash::make($request->password),
        ]);
        $user->sendEmailVerificationNotification(); // send verification email
        return response()->json(['message' => 'User created successfully.']);
    }
  
}

现在，我们可以在Lumen框架中实现我们的微服务。我们的系统现在有三个微服务模块：“用户认证和授权微服务”、“用户信息管理微服务”和“用户注册微服务”，这些微服务与数据库交互，并由Lumen API Gateway处理。

总结

本文介绍了如何在Lumen框架中集成微服务架构，包括领域模型设计、微服务接口和微服务模块的开发。以上代码展示了Lumen框架如何开发微服务的过程。通过使用Lumen框架，开发者可以快速构建微服务，提高代码质量，加快项目进程。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!