Spring Cloud | Chapitre 9 : Centre de configuration distribué Config

avant-propos

À mesure que les projets en ligne deviennent de plus en plus volumineux, chaque projet est dispersé avec divers fichiers de configuration. Si un modèle de développement distribué est adopté, les fichiers de configuration requis continueront d'augmenter à mesure que le nombre de services augmentera. Une modification des informations de service de base entraînera une série de mises à jour et de redémarrages, rendant l'exploitation et la maintenance misérables et sujettes aux erreurs. Le centre de configuration a été créé pour résoudre ces problèmes.

Pourquoi une gestion unifiée de la configuration des microservices

Dans l'architecture des microservices, la gestion de la configuration des microservices répond généralement aux exigences suivantes :

Gérez la configuration de manière centralisée. Un système d'application utilisant une architecture de microservices peut contenir des centaines ou des milliers de microservices, une gestion centralisée est donc indispensable.
Différents environnements ont des configurations différentes. Il existe différents fichiers de configuration pour le développement, les tests, la préparation et la production.
Peut être ajusté dynamiquement pendant le fonctionnement.
La configuration peut être automatiquement mise à jour après modification. Aucun redémarrage n'est requis.

Introduction à la configuration

Le projet Spring Cloud Config est une solution de gestion de configuration pour les systèmes distribués. Il comprend deux parties, Client et Serveur, Server 提供配置文件的存储、以接口的形式将配置文件的内容提供出去, Client通过接口获取数据、并依据此数据初始化自己的应用. Spring Cloud 使用 git 或 svn 存放配置文件utilise git par défaut et le démontre avec git comme code.

démarrage rapide

Construire le référentiel GIT

Tout d'abord, un dossier config-server est créé sur github pour stocker les fichiers de configuration. Afin de simuler l'environnement de production, nous créons les trois fichiers de configuration suivants :

// 开发环境
application-dev.properties
// 测试环境
application-test.properties
// 生产环境
application-pro.properties

Et une paire clé-valeur est écrite dans chaque fichier de configuration, à savoir : profile=dev-1.0、profile=test-1.0、profile=pro-1.0.
En même temps, créez une nouvelle branche nommée config-server-v2.0.
insérer la description de l'image ici

du côté serveur

Créer un nouveau projet et ajouter des dépendances

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-config-server</artifactId>
</dependency>

Modifiez la classe de démarrage Application.javaen @EnableConfigServerdéclarant qu'il s'agit du serveur du centre de configuration.

@SpringBootApplication
@EnableConfigServer
public class ConfigApplication {
      
      
    public static void main(String[] args) {
      
      
        SpringApplication.run(ConfigApplication.class, args);
    }

}

Écrire un fichier de configurationapplication.yml

server:
  port: 7376
spring:
  application:
    name: config
  cloud:
    config:
      server:
        git:
          # 配置git仓库的地址
          uri: 
          # git仓库用户名
          username: 
          # git仓库密码
          password:

Test après lancement. Tout d'abord, nous devons tester si le serveur peut lire les informations de configuration sur github, et accéder directement :http://localhost:7376/applicatiom/pro

Les informations renvoyées sont les suivantes :
```
{
      
      
	name: "applicatiom",
	profiles: [
		"pro"
	],
	label: null,
	version: "0dc8f44a675ab935b919962e294edcd864ed6306",
	state: null,
	propertySources: [
		{
      
      
			name: "https://github.com/Sun-xyu/config-server.git/application-pro.properties",
			source: {
      
      
				profile: "pro-1.0"
			}
		}
	]
}
```
Les informations renvoyées ci-dessus incluent le fichier de configuration 位置、版本、配置文件的名称以及配置文件中的具体内容, indiquant que le serveur a réussi à obtenir les informations de configuration de l'entrepôt git.

Si vous affichez directement les informations de configuration dans le fichier de configuration, vous pouvez accéder à : http://localhost:7376/applicatiom-dev.propertieset renvoyer :profile: dev-1.0

Si vous visualisez directement les informations de configuration dans le fichier de configuration de la branche, vous pouvez accéder à : http://localhost:7376/config-server-v2.0/applicatiom-dev.properties, et renvoyer :profile: dev-2.0

Ajoutez les informations de configuration dans le fichier de configuration applicatiom-dev.properties sous la forme :config: this is config server dev1.0 , visitez à nouveau dans le navigateur http://localhost:7376/applicatiom-dev.propertieset renvoyez :config: this is config server dev1.0 profile: dev-1.0 . Expliquez que le serveur lira automatiquement le dernier contenu soumis

Les fichiers de configuration de l'entrepôt seront convertis en interfaces web, et l'accès pourra se référer aux règles suivantes :

/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

À titreapplication-dev.properties d'exemple, applicationc'est application, profileest dev, labelest master. Le client choisira de lire la configuration correspondante en fonction des paramètres renseignés.

Client

Créer un nouveau projet et ajouter des dépendances

<dependencies>
	<dependency>
		<groupId>org.springframework.cloud</groupId>
		<artifactId>spring-cloud-starter-config</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
</dependencies>

Créez une classe de démarrage normale Application.java.

@SpringBootApplication
public class ConfigclientApplication {
      
      
    public static void main(String[] args) {
      
      
        SpringApplication.run(ConfigclientApplication.class, args);
    }
}

Pour écrire un fichier de configuration, vous devez configurer deux fichiers de configuration, application.propertieset bootstrap.properties
application.properties sont les suivants :
```
server:
  port: 7377
spring:
  application:
    name: config-client
```
Les propriétés bootstrap.properties sont les suivantes :
```
spring:
 application:
   # 对应config server 的配置文件的{application｝
   name: client
 cloud:
   config:
     # 对应config server 地址
     uri: http://localhost:7376
     # 对应config server 所获取的配置文件的 {profile}
     profile: dev
     # 指定git仓库的分支，对应获取配置文件的{lable}
     label: master
```
- spring.application.name : correspond à la partie {application}
- spring.cloud.config.profile : correspondant à la partie {profile}
- spring.cloud.config.label : correspondant à la branche de git. Si le centre de configuration utilise le stockage local, ce paramètre est inutile
- spring.cloud.config.uri : l'adresse précise du centre de configuration
- spring.cloud.config.discovery.service-id : Spécifie l'ID de service du centre de configuration, qui est facile à étendre vers un cluster de configuration à haute disponibilité.
Attention particulière : les propriétés liées à Spring-Cloud ci-dessus doivent être configurées dans bootstrap.properties, afin que le contenu de la partie de configuration puisse être chargé correctement. Parce que la configuration pertinente de config sera antérieure à application.properties, et le chargement de bootstrap.properties est également antérieur à application.properties.

Écrivez des classes de test. Utilisez l'annotation @Value pour obtenir la valeur du paramètre côté serveur

@RestController
public class ConfigClientController {
      
      

    @Value("${config}")
    private String config;

    @GetMapping("/config")
    public String helloConfig(){
      
      
        return config;
    }
}

Test, accès au navigateur http://localhost:7377/config, retour this is config server dev1.0. Lisez la configuration dans le référentiel git. Cela signifie que les paramètres ont été correctement obtenus auprès du serveur. À ce stade, un serveur complet fournit des services de configuration et l'exemple du client obtenant des paramètres de configuration est terminé.

résumé

L'exemple du centre de configuration est expliqué. Si vous modifiez manuellement application-dev.propertiesles informations de configuration dans :config=this is config server dev1.0 commit again Soumettre à github, visitez à nouveau dans le navigateur http://localhost:7377/configet retournez :this is config server dev1.0 , indiquant que les informations obtenues sont toujours l'ancien paramètre, pourquoi ? Étant donné que le projet SpringBoot n'obtiendra la valeur du fichier de configuration qu'au démarrage, après avoir modifié les informations de github, le côté client ne la récupèrera plus, ce qui conduit à ce problème. Comment résoudre ce problème? Je le présenterai en détail la prochaine fois.