PHP und Lumen werden integriert, um die Entwicklung einer Microservice-Architektur zu realisieren

Mit der rasanten Entwicklung der IT-Technologie sind moderne Unternehmen mit immer komplexeren Geschäftssystemen konfrontiert. Die traditionelle Einzelanwendungsarchitektur kann den Anforderungen nicht mehr gerecht werden, und die Microservice-Architektur ist mit der Zeit entstanden. Microservice-Architektur ist ein Architekturstil, bei dem Anwendungen aus mehreren kleinen Diensten bestehen, die unabhängig voneinander bereitgestellt, ausgeführt, erweitert und gewartet werden können, um eine bessere Skalierbarkeit, Wiederverwendbarkeit und Flexibilität zu erreichen.

Wie kann man also PHP verwenden, um eine Microservice-Architektur zu implementieren? Die Antwort ist die Verwendung von Lumen – einem leichten PHP-Framework. Basierend auf Laravel ist Lumen ein PHP-Framework, das für die Erstellung von Microservices und APIs entwickelt wurde. In diesem Artikel wird vorgestellt, wie man eine Microservice-Architektur in das Lumen-Framework integriert.

Schritt 1: Lumen installieren

Zuerst müssen wir das Lumen-Framework lokal installieren. Die Installationsschritte sind die gleichen wie für Laravel. Es kann über Composer installiert werden, wie unten gezeigt:

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

Nach Abschluss können wir die Lumen-Framework-Laufumgebung lokal starten:

php -S localhost:8000 -t public

Wenn „Lumen-Entwicklungsserver gestartet: 9e9ead522d5c283aed9850c47cee60c2“ erscheint, Dies zeigt an, dass das Lumen-Framework die lokale Betriebsumgebung erfolgreich bereitgestellt hat und wir über http://localhost:8000 auf die Standardseite zugreifen können.

Schritt zwei: Microservices schreiben

Als nächstes werden wir das Lumen-Framework verwenden, um unseren ersten Microservice zu schreiben. Wir werden eine einfache API erstellen, die eine Liste aller Benutzer erhält. Die Schritte zum Implementieren dieser API sind wie folgt:

1. API-Routen erstellen

In der Routing-Datei „routes/web.php“ müssen wir eine Route schreiben, um Anfragen an die API zu verarbeiten. In diesem Beispiel schreiben wir eine GET-Route in die Routing-Datei, um die /get_users-Anfrage zu verarbeiten, wie unten gezeigt:

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

Wenn Sie zu diesem Zeitpunkt http://localhost:8000/get_users anfordern, wird „List“ angezeigt von allen Benutzern zurückgegebene Zeichenfolge.

2. API-Anfragen verarbeiten

Jetzt müssen wir eine Controller-Klasse für unsere API erstellen. Erstellen wir die UserController-Klasse, die für die Verarbeitung der get_users-Anfrage und die Rückgabe der Benutzerliste verantwortlich ist. Wir können die Datei UserController.php im Verzeichnis app/Http/Controllers erstellen und den folgenden Code hineinkopieren:

<?php

namespace AppHttpControllers;

use IlluminateHttpRequest;

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

Im obigen Code haben wir eine öffentliche Funktion getAllUsers() definiert, die die Liste aller Benutzer als Antwort zurückgibt im JSON-Format.

3. API-Route zum Controller registrieren

Jetzt müssen wir die API-Route zum UserController-Controller in der Routendatei registrieren, unsere Route /api/get_users der Methode UserController@getAllUsers zuordnen und die Routendatei wie gezeigt ändern unten:

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

Wenn Sie zu diesem Zeitpunkt http://localhost:8000/api/get_users anfordern, wird eine Benutzerliste im JSON-Format zurückgegeben, wie unten gezeigt:

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

Schließlich müssen wir auch den UserController importieren Klasse oben, wie folgt. Gezeigt:

<?php

use AppHttpControllersUserController;

Auf diese Weise haben wir erfolgreich eine grundlegendste API implementiert und können unter dem Lumen-Framework ausgeführt werden.

Schritt 3: Microservices-Framework integrieren

Zuvor haben wir unsere erste API im Lumen-Framework erstellt, es handelt sich jedoch nicht um eine echte Microservices-Anwendung. Um Lumen in eine Microservice-Architekturanwendung umzuwandeln, müssen wir Designideen für DDD-Domänenmodelle verwenden, um unsere Anwendung neu zu erstellen. Anschließend werden wir die Idee der Microservices nutzen, um jeden unserer Services in Microservices zu zerlegen.

1. Domänendesign

Zunächst müssen wir unser Domänenmodell definieren, das den Kern unserer Anwendung bildet. In diesem Beispiel erstellen wir einen einfachen Microservice zur Benutzerverwaltung, dessen Hauptfunktion darin besteht, Benutzerdaten zu verwalten.

Unser Benutzerverwaltungs-Microservice muss über die folgenden Funktionen verfügen:

• Benutzerregistrierung
• Benutzerauthentifizierung
• Benutzerautorisierung
• Benutzerinformationsverwaltung

Jetzt müssen wir diese Funktionen der Schnittstelle des Microservice zuordnen.

2. Microservice-Schnittstelle

Wir werden verschiedene Microservice-Schnittstellen entsprechend unterschiedlichen Funktionen im Domänenmodell entwerfen. Hier definieren wir die folgenden Microservice-Schnittstellen:

• Benutzerregistrierungsschnittstelle (registerUser)
• Benutzerauthentifizierungsschnittstelle (authenticateUser)
• Benutzerautorisierungsschnittstelle (authorizeUser)
• Benutzerinformationsverwaltungsschnittstelle (manageUserInfo)

3. Microservice-Modul

Jetzt müssen wir unsere Microservice-Schnittstelle in verschiedene Microservice-Module unterteilen. In diesem Beispiel verwenden wir die folgenden drei Microservice-Module:

• User Authentication and Authorization Microservice
• User Information Management Microservice
• User Registration Microservice

Diese Microservice-Module stellen eine direkte Schnittstelle zu unserer Datenbank her, um zu interagieren.

4. Microservices-Architektur

Wir verfügen nun über die Komponenten unseres Domänenmodells, Microservice-Schnittstellen und Microservice-Module und können diese nun einfach zu einer Microservices-Architektur kombinieren. Die gesamte Architektur sieht so aus:

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

Wir aktivieren das Lumen API Gateway, das den Ausgangspunkt unseres Systems darstellt und alle Anfragen empfängt und an das entsprechende Microservice-Modul weiterleitet. Unser Domänenmodell ist unsere Geschäftslogik, und die Microservice-Schnittstelle steuert unsere Dateninteraktionen.

第四步：实现微服务

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

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框架，开发者可以快速构建微服务，提高代码质量，加快项目进程。

Das obige ist der detaillierte Inhalt vonPHP und Lumen werden integriert, um die Entwicklung einer Microservice-Architektur zu realisieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!