Implémentation d'une gouvernance de microservices basée sur le conteneur Spring Cloud

Avec le développement d'Internet et du cloud computing, de plus en plus d'entreprises commencent à adopter une architecture de microservices pour créer et déployer des systèmes logiciels. Dans une architecture de microservices, le système est divisé en plusieurs petites unités de service autonomes, chacune avec sa propre application, son stockage de données et sa logique métier. L'avantage de ce style architectural est qu'il améliore la résilience, l'évolutivité et la maintenabilité de l'application. Cependant, l'architecture des microservices pose également certains défis, tels que la découverte de services, l'équilibrage de charge, la tolérance aux pannes, la visualisation, etc., qui nécessitent de puissants outils de gouvernance des microservices pour être résolus. Spring Cloud est un framework de microservices basé sur Spring Boot. Il fournit une série de technologies de gouvernance de microservices pour permettre aux développeurs de créer et de gérer plus facilement des applications de microservices.

Le conteneur Spring Cloud est l'un des composants principaux de Spring Cloud. Il fournit une variété de fonctions de gouvernance de microservices, telles que l'enregistrement et la découverte de services, la gestion de la configuration, les disjoncteurs, etc. Dans cet article, nous présenterons comment mettre en œuvre la gouvernance des microservices à l'aide des conteneurs Spring Cloud.

1. Enregistrement et découverte du service

Dans l'architecture des microservices, les appels entre services nécessitent de connaître l'adresse réseau du service, et l'adresse du service change fréquemment. Cela nécessite un mécanisme d'enregistrement et de découverte du service pour gérer les adresses de service. Le conteneur Spring Cloud fournit Eureka pour résoudre ce problème.

Eureka est le composant d'enregistrement et de découverte de services open source de Netflix. Il implémente des fonctions de base d'enregistrement et de découverte de services basées sur l'API RESTful, et fournit également des fonctions avancées telles que la vérification de l'état du service, l'équilibrage de charge et le basculement. Utiliser Eureka dans Spring Cloud est très simple. Il vous suffit d'introduire les dépendances pertinentes dans le projet Spring Boot et de configurer application.yml ou application.properties. Voici un exemple simple de configuration application.yml :

spring:
  application:
    name: service-provider
  cloud:
    config:
      uri: http://config-server:8888 # 配置中心地址
    consul:
      host: consul-server # 基于Consul模式时Consul服务器地址
  profiles:
    active: dev
eureka:
  client:
    serviceUrl:
      defaultZone: http://eureka-server:8761/eureka/ # Eureka注册中心地址
  instance:
    preferIpAddress: true
  server:
    enable-self-preservation: false # 测试场景，不关闭则Eureka客户端会每隔30s向Eureka Server发送一次心跳包作为健康检查，因为测试场景是手动杀掉实例，所以不执行自我保护

Dans le fichier de configuration ci-dessus, nous avons configuré le nom du service en tant que fournisseur de services, en utilisant le centre d'enregistrement Eureka et en utilisant le centre de configuration Spring Cloud Config et la découverte du service Consul. configurations Les éléments peuvent être modifiés selon les besoins. Il est très pratique d'utiliser le centre d'enregistrement Eureka. Il vous suffit d'ajouter l'annotation @EnableEurekaClient à la classe de démarrage pour enregistrer le service sur le serveur Eureka.

2. Gestion de la configuration

Dans l'architecture des microservices, la gestion de la configuration des services est également un enjeu très important. Spring Cloud fournit le composant Config Server pour implémenter la gestion de la configuration des microservices. Config Server peut stocker les informations de configuration localement (outils de gestion de code tels que Git, Svn) ou dans des référentiels distants (tels que GitHub), et le client peut utiliser l'API Restful pour obtenir la configuration. informations et actualiser automatiquement le cache.

Utiliser Config Server dans Spring Cloud est très simple. Il vous suffit d'introduire les dépendances pertinentes dans le projet Spring Boot et de configurer application.yml ou application.properties. Voici un exemple simple de configuration application.yml :

spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://github.com/Alice52/spring-cloud-config-example.git # 配置文件所在的远程仓库
          search-paths: {config} # 配置文件所在的搜索路径
server:
  port: 8888 # 配置Server的端口

Dans le fichier de configuration ci-dessus, nous avons configuré le nom du serveur de configuration en tant que serveur de configuration, le port démarré en tant que 8888 et avons utilisé Git pour gérer le fichier de configuration. est https://github.com/Alice52/spring-cloud-config-example.git. Pour le client, il vous suffit d'ajouter les annotations @EnableAutoConfiguration et @EnableConfigServer à la classe de démarrage pour permettre au client d'obtenir des informations de configuration à partir du serveur de configuration.

3. Appel de service

Dans l'architecture des microservices, les services s'appellent via l'API RESTful basée sur le réseau. Cependant, pour les appels de service, un équilibrage de charge est parfois nécessaire, et une protection par disjoncteur est également requise pour éviter la dégradation du service ou les temps d'arrêt. .

Spring Cloud fournit le composant Ribbon pour fournir une fonction d'équilibrage de charge, et fournit également un composant Hystrix pour fournir une fonction de disjoncteur. L'utilisation de Ribbon et Hystrix dans Spring Cloud est également très simple. Il vous suffit d'introduire les dépendances pertinentes dans le projet Spring Boot et de configurer application.yml ou application.properties. Voici un exemple simple de configuration application.yml :

spring:
  application:
    name: service-consumer
server:
  port: 8080
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    preferIpAddress: true
    instanceId: ${spring.cloud.client.ipAddress}:${spring.application.name}:${server.port}
  server:
    enable-self-preservation: false # 测试场景，不关闭则Eureka客户端会每隔30s向Eureka Server发送一次心跳包作为健康检查，因为测试场景是手动杀掉实例，所以不执行自我保护

Dans le fichier de configuration ci-dessus, nous avons configuré le nom du service en tant que consommateur de service, utilisé le centre d'enregistrement Eureka et activé le mécanisme d'autoprotection du service pour empêcher Eureka Le serveur n'a pas été découvert. Le service a échoué et a été supprimé. Lorsque le client appelle le service, il utilise Ribbon pour l'équilibrage de charge et configure également Hystrix comme disjoncteur pour garantir la haute disponibilité et la stabilité du service.

4. Résumé

Cet article explique comment utiliser le conteneur Spring Cloud pour mettre en œuvre la gouvernance des microservices, y compris l'enregistrement et la découverte des services, la gestion de la configuration et l'invocation de services. Grâce à des composants tels qu'Eureka, Config Server, Ribbon et Hystrix fournis par Spring Cloud, les développeurs peuvent plus facilement créer et gérer des applications de microservices. Bien entendu, de nombreux autres aspects sont impliqués dans l'architecture des microservices, tels que les passerelles de services, le suivi distribué et la gestion des clés secrètes. Nous présenterons ces contenus dans les articles suivants.

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!