Comment implémenter des microservices en utilisant PHP ?

Cet article vous présentera comment utiliser PHP pour implémenter des microservices ? Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Pourquoi devrions-nous parler de gouvernance des services

Alors que la navigation sur Internet devient de plus en plus grande, l'architecture unique MVC traditionnelle continue de se développer avec l'échelle. d'applications. , les modules d'application continuent d'augmenter, l'ensemble de l'application devient de plus en plus volumineux et la maintenance devient plus difficile.

Nous devons prendre des mesures pour diviser par application, c'est-à-dire diviser l'application d'origine en plusieurs applications. selon les caractéristiques métiers de l'application. Par exemple, un grand système de commerce électronique peut inclure un système utilisateur, un système produit, un système de commande, un système d'évaluation, etc. Nous pouvons les séparer en applications distinctes. La particularité de l'architecture multi-applications est que les applications sont indépendantes et ne s'appellent pas entre elles.

Bien que plusieurs applications résolvent le problème des applications surchargées, les applications sont indépendantes les unes des autres et certaines entreprises ou codes courants ne peuvent pas être réutilisés.

Solution d'application unique

Pour un grand système Internet, il contient généralement plusieurs applications, et il existe souvent des services communs entre les applications, et il existe également des relations d'appel entre les applications. En outre, les systèmes Internet à grande échelle présentent d'autres défis, tels que la manière de gérer la croissance rapide du nombre d'utilisateurs, la manière de gérer l'équipe de R&D pour itérer rapidement le développement de produits, la manière de maintenir la stabilité des mises à niveau des produits, etc.

Par conséquent, afin de rendre l'activité réutilisable et le module plus facile à développer et à maintenir, nous espérons séparer l'activité de l'application. Une certaine activité n'appartient plus à une application, mais est effectuée séparément en tant qu'application. service indépendant. L'application elle-même n'est plus une pile de modules surchargée, mais est composée de composants de service modulaires.

Orienté service

Fonctionnalités

Alors, quelles sont les fonctionnalités intéressantes de l'utilisation de 服务化 ?

• Application Divisé en services selon l'activité
• Chaque service peut être déployé indépendamment
• Les services peuvent être partagés par plusieurs applications
• Les services peuvent communiquer entre eux
• Architecturalement Le système est plus clair
• Le module de base est stable et mis à niveau en unités de composants de service, évitant les risques causés par des versions fréquentes
• Développement et gestion pratiques
• Maintenance et équipe séparées travail clair, responsabilités claires
• Réutilisation commerciale, réutilisation du code
• Très facile à développer

Défis rencontrés par les personnes orientées service

Après le système est orienté service, L'augmentation de la complexité des dépendances augmentera également le nombre d'interactions entre les services. En mode développement de fpm, car elle ne peut pas résider en mémoire, chaque requête doit être chargée à partir de zéro jusqu'à la fin du processus. ajoutant beaucoup de surcharge inutile, la connexion à la base de données ne peut pas être réutilisée et ne peut pas être protégée Puisque fpm est basé sur le processus, le nombre de fpm processus détermine également le nombre de concurrence. C'est aussi la raison pour laquelle fpm. le développement est simple. Les problèmes que nous apportons. Alors pourquoi la plateforme Internet Java est-elle plus populaire maintenant, mais ni .NET ni PHP ne sont bons à cet égard. Inutile de le dire PHP非内存常驻. Au-delà de cela, de nombreux autres problèmes doivent être résolus.

• Il y a de plus en plus de services, et la gestion de la configuration est complexe
• Les dépendances entre services sont complexes
• Équilibrage de charge entre services
• Extension des services
• Surveillance des services
• Rétrogradation du service
• Authentification du service
• Service en ligne et hors ligne
• Documentation du service...

Vous pouvez imaginer les avantages que nous apporte la mémoire résidente, tels que

• Démarrer uniquement l'initialisation du framework Si la mémoire résidente nous, elle ne gère que l'initialisation du framework en mémoire au démarrage, et se concentre sur le traitement des requêtes

• réutilisation des connexions Certains ingénieurs ne comprennent pas particulièrement cela si un pool de connexions n'est pas utilisé. , Que diriez-vous simplement d'envoyer une connexion lorsqu'une demande arrive ? Cela entraînera un trop grand nombre de connexions aux ressources backend. Pour certains services de base, comme Redis et la base de données, les connexions sont coûteuses.

Alors, y a-t-il une bonne solution ? La réponse est oui, et de nombreuses personnes utilisent ce framework, qui est - Swoft. Swoft est un framework RPC avec la fonction 服务治理. Swoft est le premier framework full-stack de coroutine de mémoire résidente PHP, basé sur le concept de base proposé par Spring Boot selon lequel la convention est supérieure à la configuration

Swoft offre une manière plus élégante d'utiliser les services Dubbo similaires à RPC Les performances Swoft sont très bonnes et similaires aux performances Golang Voici mes performances PC contre Swoft. performances La situation du test de stress.

abLa vitesse de traitement du test de stress est très étonnante, en i78代CPU, 16GB Mémoire下100000万个请求只用了5s时间在fpm开发模式下基本不可能达到. 这也足以证明Swoft` Haute performance et stabilité,

Gouvernance des services élégante

Enregistrement et découverte des services

Dans le processus de gouvernance des microservices, services enregistrés et démarrés sont souvent impliqués dans des clusters tiers, tels que consul/etcd, etc., ce chapitre utilise le composant swoft-consul du framework Swoft comme exemple pour implémenter l'enregistrement et la découverte de services.

Implémenter la logique

<?php declare(strict_types=1);namespace App\Common;use ReflectionException;use Swoft\Bean\Annotation\Mapping\Bean;use Swoft\Bean\Annotation\Mapping\Inject;use Swoft\Bean\Exception\ContainerException;use Swoft\Consul\Agent;use Swoft\Consul\Exception\ClientException;use Swoft\Consul\Exception\ServerException;use Swoft\Rpc\Client\Client;use Swoft\Rpc\Client\Contract\ProviderInterface;/**
 * Class RpcProvider
 *
 * @since 2.0
 *        
 * @Bean()
 */class RpcProvider implements ProviderInterface{    /**
     * @Inject()
     *
     * @var Agent
     */
    private $agent;    /**
     * @param Client $client
     *
     * @return array
     * @throws ReflectionException
     * @throws ContainerException
     * @throws ClientException
     * @throws ServerException
     * @example
     * [
     *     &#39;host:port&#39;,
     *     &#39;host:port&#39;,
     *     &#39;host:port&#39;,
     * ]
     */
    public function getList(Client $client): array
    {        // Get health service from consul
        $services = $this->agent->services();

        $services = [
        
        ];        return $services;
    }
}

Disjoncteur de service

Dans un environnement distribué, en particulier un système distribué avec une structure de microservices, il est très difficile pour un système logiciel d'appeler un autre système distant système. L'appelé de cet appel distant peut être un autre processus ou un autre hôte sur le réseau. La plus grande différence entre cet appel distant et l'appel interne du processus est que l'appel distant peut échouer ou se bloquer sans réponse avant l'expiration du délai. Ce qui est pire, c'est que si plusieurs appelants appellent le même service suspendu, il est très probable que le délai d'attente d'un service se propage rapidement à l'ensemble du système distribué, provoquant une réaction en chaîne et consommant l'ensemble des ressources du système distribué. Cela peut éventuellement conduire à une défaillance du système.

Le mode disjoncteur vise à prévenir les catastrophes causées par de telles réactions en chaîne semblables à une cascade dans les systèmes distribués.

Le mode disjoncteur de base garantit que le fournisseur de protection ne sera pas appelé lorsque le disjoncteur est à l'état ouvert, mais nous avons également besoin de mesures supplémentaires pour réinitialiser le disjoncteur après la reprise du service par le fournisseur. Une approche réalisable consiste pour le disjoncteur à détecter périodiquement si le service du fournisseur a été rétabli et, une fois rétabli, à définir l'état sur fermeture. Le disjoncteur est à moitié ouvert lors d'une nouvelle tentative.

L'utilisation des fusibles est simple et puissante. Il suffit d'utiliser une @Breaker annotation. Swoft les fusibles peuvent être utilisés dans n'importe quel scénario, par exemple lors d'un appel à un service ou lors d'une demande à un tiers. disjoncteur et déclassé

<?php declare(strict_types=1);namespace App\Model\Logic;use Exception;use Swoft\Bean\Annotation\Mapping\Bean;use Swoft\Breaker\Annotation\Mapping\Breaker;/**
 * Class BreakerLogic
 *
 * @since 2.0
 *
 * @Bean()
 */class BreakerLogic{    /**
     * @Breaker(fallback="loopFallback")
     *
     * @return string
     * @throws Exception
     */
    public function loop(): string
    {        // Do something
        throw new Exception(&#39;Breaker exception&#39;);
    }    /**
     * @return string
     * @throws Exception
     */
    public function loopFallback(): string
    {        // Do something
    }
}

Limitation de courant de service

Limitation de courant, disjoncteur, déclassement On ne saurait trop le souligner, car c'est en effet très important. En cas de panne du service, le fusible doit être débranché. La limitation de courant est le plus grand outil pour vous protéger. S'il n'y a pas de mécanisme d'autoprotection, quel que soit le nombre de connexions, elle sera reçue. Si le backend ne peut pas le gérer, le frontend se bloquera définitivement lorsque le trafic est très important. .

La limitation actuelle consiste à limiter le nombre de concurrences et de requêtes lors de l'accès à des ressources rares, telles que les ventes flash et les produits en vente urgente, réduisant ainsi efficacement les pics et lissant la courbe de trafic. Le but de la limitation actuelle est de limiter le taux d'accès simultané et de demandes simultanées, ou de limiter le taux de demandes dans une fenêtre de temps pour protéger le système. Une fois la limite de débit atteinte ou dépassée, le service peut être refusé ou mis en file d'attente. et j'ai attendu.

Swoft La couche inférieure du limiteur de courant utilise l'algorithme du compartiment à jetons, et la couche inférieure s'appuie sur Redis pour implémenter la limitation de courant distribuée.

Le limiteur de débit Swoft peut non seulement limiter le contrôleur actuel, mais également limiter les méthodes dans n'importe quel bean et contrôler le taux d'accès de la méthode. Voici une explication détaillée de la clé

<?php declare(strict_types=1);namespace App\Model\Logic;use Swoft\Bean\Annotation\Mapping\Bean;use Swoft\Limiter\Annotation\Mapping\RateLimiter;/**
 * Class LimiterLogic
 *
 * @since 2.0
 *
 * @Bean()
 */class LimiterLogic{    /**
     * @RequestMapping()
     * @RateLimiter(rate=20, fallback="limiterFallback")
     *
     * @param Request $request
     *
     * @return array
     */
    public function requestLimiter2(Request $request): array
    {
        $uri = $request->getUriPath();        return [&#39;requestLimiter2&#39;, $uri];
    }    
    /**
     * @param Request $request
     *
     * @return array
     */
    public function limiterFallback(Request $request): array
    {
        $uri = $request->getUriPath();        return [&#39;limiterFallback&#39;, $uri];
    }
}

avec l'exemple d'utilisation suivant symfony/expression-language l'expression est prise en charge ici. Si le débit est limité, la méthode fallback définie dans limiterFallback sera appelée. >

Centre de configuration

Avant de parler du centre de configuration, parlons d'abord du fichier de configuration qui nous est familier. Il nous offre la possibilité de modifier dynamiquement les capacités d'exécution du programme. Pour citer les mots de quelqu'un d'autre :

Ajustement dynamique de l'attitude de vol pendant l'exécution du système !

Je pourrais appeler notre travail la réparation de pièces sur un avion volant à grande vitesse. Nous, les humains, ne pouvons pas toujours tout contrôler et tout prévoir. Pour notre système, nous devons toujours réserver certaines lignes de contrôle pour effectuer des ajustements lorsque nous devons contrôler la direction du système (comme le contrôle des niveaux de gris, l'ajustement de la limite de courant). Ceci est particulièrement important pour l'industrie Internet qui s'adapte aux changements.

Pour la version autonome, nous l'appelons la configuration (fichier) ; pour le système de cluster distribué, nous l'appelons le centre de configuration (système)

Qu'est-ce que la configuration distribuée exactement ; centre

Avec le développement des affaires et la mise à niveau de l'architecture des microservices, le nombre de services et de configurations de programmes augmente de jour en jour (divers microservices, diverses adresses de serveur, divers paramètres), les méthodes traditionnelles de fichiers de configuration et les méthodes de base de données Les exigences des développeurs en matière de gestion de configuration ne peuvent plus être satisfaites :

• 安全性：配置跟随源代码保存在代码库中，容易造成配置泄漏；
• 时效性：修改配置，需要重启服务才能生效；
• 局限性：无法支持动态调整：例如日志开关、功能开关；

因此，我们需要配置中心来统一管理配置！把业务开发者从复杂以及繁琐的配置中解脱出来，只需专注于业务代码本身，从而能够显著提升开发以及运维效率。同时将配置和发布包解藕也进一步提升发布的成功率，并为运维的细力度管控、应急处理等提供强有力的支持。

关于分布式配置中心，网上已经有很多开源的解决方案，例如：

Apollo是携程框架部门研发的分布式配置中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并且具备规范的权限、流程治理等特性，适用于微服务配置管理场景。

本章以Apollo 为例，从远端配置中心拉取配置以及安全重启服务。如果对 Apollo 不熟悉，可以先看Swoft 扩展 Apollo 组件以及阅读 Apollo 官方文档。

本章以 Swoft 中使用 Apollo 为例，当 Apollo 配置变更后，重启服务(http-server / rpc-server/ ws-server)。如下是一个 agent 例子：

<?php declare(strict_types=1);namespace App\Model\Logic;use Swoft\Apollo\Config;use Swoft\Apollo\Exception\ApolloException;use Swoft\Bean\Annotation\Mapping\Bean;use Swoft\Bean\Annotation\Mapping\Inject;/**
 * Class ApolloLogic
 *
 * @since 2.0
 *
 * @Bean()
 */class ApolloLogic{    /**
     * @Inject()
     *
     * @var Config
     */
    private $config;    /**
     * @throws ApolloException
     */
    public function pull(): void
    {
        $data = $this->config->pull(&#39;application&#39;);        
        // Print data
        var_dump($data);
    }
}

以上就是一个简单的 Apollo 配置拉取，Swoft-Apollo 除此方法外，还提供了更多的使用方法。

官方链接

• Github
• Doc
• swoft-cloud/community

推荐学习：php视频教程

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!