Solution de centre de configuration Spring Cloud+Kubernetes pour l'architecture cloud native

Un aperçu du programme

L'utilisation des ressources configmap/secret natives de Kubernetes en tant que centre de configuration n'a pas besoin de prêter attention à la disponibilité des services, c'est-à-dire aux problèmes de réseau, et n'a pas besoin d'introduire de nouveaux composants, ce qui entraîne des coûts d'exploitation et de maintenance.

Deux solutions de centre de configuration SpringCloudKubernetes

2.1 Présentation du programme

2.1.1 spring-cloud-starter-kubernetes-config

spring-cloud-starter-kubernetes-config est une bibliothèque sous spring-cloud-starter-kubernetes, qui est utilisée pour combiner le configmap de kubernetes avec SpringCloud Config. spring-boot-actuator /  spring-boot-actuator-autoconfigure L'introduction des deux packages permet à l'application d'être mise à jour à chaud. Lorsque le configmap/secret change, la configuration du changement à chaud peut être effectuée sans redémarrer le pod ou le processus.

2.1.2 Présentation des fonctions

Le composant SpringCloud Kubernetes Config fournit principalement les fonctions suivantes :

• Surveillez les changements de configuration ConfigMap et Secret en temps réel pour mettre à jour les configurations de service.
• L'interrogation régulière charge les configurations ConfigMap et Secret pour mettre à jour les configurations de service.

2.2 Processus de découverte de configuration

Essentiellement, la gestion de la configuration utilise le stockage d'etcd. Tout d'abord, l'application appelle le package spring-cloud-kubernetes-config, qui appelle le client kubernetes implémenté par le Java sous-jacent, et obtient la configmap et les informations sur les ressources secrètes d'etcd par appelant l'API k8s.

2.3 Caractéristiques du programme

• avantage:
  • En utilisant les ressources intégrées de K8, il n'est pas nécessaire d'envisager l'introduction de services de centre de configuration, ni de prendre en compte la haute disponibilité des services de centre de configuration.
  • Architecture cloud-native, le centre de configuration s'enfonce dans la couche infrastructure, sans couplage de code métier, réduisant les coûts.
• insuffisant:
  • L'environnement de développement/test doit également utiliser des K8 pour assurer la cohérence de l'environnement.
  • La ressource de configuration configmap/secret doit être introduite dans le processus GitOps.

Trois combats

Créez un nouveau fichier de configuration bootstrap.yml, et l'application finale.yaml utilise la ressource k8s configmap/secret.

spring: 
  profiles: 
    ## Si PROFILE est vide, utilisez dev 
    active: ${PROFILE:dev} 
  application: 
    name: springboot-config 
  cloud: 
    # Monitor k8s configmap/secret api to get configuration 
    kubernetes: 
      reload: 
        #Automatically update the configuration switch Set to open 
        enabled : true 
        #Update configuration information mode : polling is active pull, event is event notification 
        mode : polling 
        #Active pull interval is 500 milliseconds 
        period: 500 
        #Whether to monitor Secret changes to perform update 
        monitoring- secrets: true 

      config: 
        espace de noms : 
        nom de springconfig : ${spring.application.name}-cm 
        enable-api : vrai 
      # le mode ne démarre que l'acquisition de configmap, permet au secret d'utiliser enable-api
      secrets : 
        namespace : springconfig 
        name : ${spring.application.name}-secret 
        #labels : #Spécifiez le nom du libellé du libellé, filtrez le secret en fonction de ce libellé et lisez la configuration 
        # secret : activé #Gestion personnalisée des libellés


: 
  endpoint : 
    redémarrez : 
      activé : vrai 
    santé : 
      activé : vrai 
    info : 
      activé : vraiCopier 
le code

Trois méthodes d'obtention de configuration sont simulées ici :

Environnement de propriétés de configuration

3.1 Carte de configuration

3.1.1 méthode de la valeur

// -----------------valeur configmap----------------- 
@Value("${config.applicationVersion}") 
applicationVersion de chaîne privée ; 

@Value("${config.app.domain}") 
domaine de chaîne privé ; 


// valeur de configmap 
@RequestMapping("/value") 
public String value() { 
    return applicationVersion + "|" + domaine ; 
}
复制代码

3.1.2 Propriétés de configuration

@Data 
@ConfigurationProperties(prefix = "config") 
@Component 
public class SpringBootConfigProperties { 
    chaîne privée applicationVersion ; 

    public String getApplicationVersion() { 
        return applicationVersion ; 
    } 
} 

// -----------------properties configmap----------------- 
@Autowired 
private SpringBootConfigProperties springBootConfigProperties; 

// configmap properties 
@RequestMapping("/properties") 
public String property() { 
    return springBootConfigProperties.getApplicationVersion(); 
}
复制代码

3.1.3 Environnement

// -----------------env configmap & secret----------------- 
@Autowired 
environnement d'environnement privé ; 

// configmap env 
@RequestMapping("/env") 
public String env() { 
    return environment.getProperty("config.applicationVersion") + "|" + environnement.getProperty("config.app.domain"); 
}
复制代码

3.2 Secrète

3.2.1 valeur

// -----------------valeur secret----------------- 
@Valeur("${secret.nomutilisateur}") 
nom d'utilisateur de chaîne privée ; 

@Value("${secret.password}") 
Chaîne privée mot de passe ; 


// valeur secrète 
@RequestMapping("/valuesecret") 
public String values() { 
    return username + "|" + mot de passe ; 
}
复制代码

3.2.2 Propriétés de configuration

@ConfigurationProperties("secret") 
@Component 
@Data 
public class SpringBootConfigPropertiesSecret { 
    chaîne privée nom d'utilisateur ; 
    mot de passe de chaîne privé ; 

} 

// -----------------properties secret----------------- 
@Autowired 
private SpringBootConfigPropertiesSecret springBootConfigPropertiesSecret ; 

// propriétés secrètes 
@RequestMapping("/propertiessecret") 
public String properties() { 
    return springBootConfigPropertiesSecret.getUsername() + "|" + springBootConfigPropertiesSecret.getPassword(); 
}
复制代码

3.2.3 Environnement

// -----------------env configmap & secret----------------- 
@Autowired 
environnement d'environnement privé ; 

// secret env 
@RequestMapping("/envsecret") 
public String envs() { 
    return environment.getProperty("secret.username") + "|" + environnement.getProperty("secret.password"); 
}
复制代码

3.3 Structure du répertoire du projet

3.4 Fichier de déploiement K8s

3.4.1 Déploiement

Simulez une simple application Web springboot ici, fournissez une interface Web et renvoyez le contenu configmap/secret obtenu.

apiVersion : apps/v1 
kind : Deployment 
metadata : 
  namespace : springconfig 
  name : springboot-config 
  labels : 
    app : springboot-config 
spec : 
  répliques : 1
  sélecteur : 
    matchLabels : 
      app : springboot-config 
  template : 
    metadata : 
      labels : 
        app : springboot-config 
    spec : 
      conteneurs : 
        - nom : 
          image springboot-config : ccr.ccs.tencentyun.com/xxxxxxxxxxxxxops-dev/springbootconfig:img_v2 
          imagePullPolicy : IfNotPresent 
          # Utilisez cette variable ici pour spécifier le fichier de configuration 
          env : 
            - nom : PROFILE
              valeur : prod 
          ports : 
            - containerPort : 8080 
              protocole : TCP 

          livenessProbe : 
            httpGet : 
              port : 8080 
              chemin : /actuator/health 
            periodSeconds : 10 
            initialDelaySeconds : 3 
            terminateGracePeriodSeconds : 10 
            failureThreshold : 5 
            timeoutSeconds : 10 
          readinessProbe : 
            httpGet : 
              port : 8080 
              chemin : / actionneur/santé 
            initialDelaySeconds : 5 
            periodSeconds : 10 
            failureThreshold : 5
            timeoutSecondes : 10Copier le 
code

3.4.2 Carte de configuration

Créez une ressource configmap contenant le contenu de l'environnement dev/test/prod. Utilisez spécifiquement cette configuration et transmettez la variable d'environnement PROFILE dans le déploiement.

kind : ConfigMap 
apiVersion : v1 
metadata : 
  name : springboot-config-cm 
  namespace : springconfig 
data : 
  application.yml : |- 
    spring : 
      profiles : dev 
    config : 
      applicationVersion : dev-0.0.1 
      app : 
        domaine : dev.web.app. com 
        domaine api : devapi.web.app.com 
        auth-callback-api : https://dev.web.app.com/dev/wx/bind-callback 
        aws-proxy-host : 192.168.9.82 
        aws-proxy- port : 8118 
        cors-allowed-origins : http://local.web.app.com, https://dev.web.app.com 
    --- 
    spring : 
      profiles : test 
    config :
      applicationVersion : test-0.0.1 
      app : 
        domaine : test.web.app.com 
        api-domain : testapi.web.app.com 
        auth-callback-api : https://test.web.app.com/dev/wx /bind-callback 
        aws-proxy-host : 192.168.9.82 
        aws-proxy-port : 8118 
        cors-allowed-origins : http://local.web.app.com, https://test.web.app.com 
    - -- 
    printemps : 
      profils : prod 
    config : 
      applicationVersion : prod-0.0.1 
      app : 
        domaine : web.app.com 
        api-domain : api.web.app.com 
        auth-callback-api : https://web.app. com/dev/wx/bind-callback 
        aws-proxy-host : 192.168.9.82
        aws-proxy-port : 8118 
        cors-allowed-origins : http://web.app.com, https://web.app.com 
Copier le code

3.4.3 Secret

Le secret stocke des informations relativement sensibles (bien que le secret dans K8s utilise le cryptage base64, il peut coopérer avec le coffre-fort pour résoudre le problème de sécurité de la configuration K8s plus tard)

apiVersion : v1 
kind : 
Type de secret : Opaque 
metadata : 
  name : springboot-config-secret 
  namespace : springconfig 
  labels : 
    secret : enabled 
data : 
  secret.username : YWRtaW4NCg== 
  secret.password : MTIzNDU2
复制代码

3.4.4 Entretien

Puisqu'il s'agit d'une application Web, elle fournit une interface de service exposée.

apiVersion : v1 
kind : Service 
metadata : 
  name : springbootconfig 
  namespace : springconfig 
  labels : 
    app : springboot-config 
spec : 
  ports : 
    - port : 8080 
      protocol : TCP 
      targetPort : 8080 
  type : clusterIP 
  selector : 
    app : springboot-config
复制代码

3.5 Code source du projet

Emplacement du projet :  github.com/redhatxl/cl…

3.6 Paramètres de configuration

3.6.1 Paramètres configurables de ConfigMap

le nom du paramètre	taper	Valeurs par défaut	Paramètre Description
spring.cloud.kubernetes.config.enabled	booléen	vrai	Activer ou non la configuration dynamique de Config
spring.cloud.kubernetes.config.name	Chaîne	${spring.application.name}	Définissez le nom de la ConfigMap à rechercher
spring.cloud.kubernetes.config.namespace	Chaîne	Espace de noms client	Définir l'espace de noms Kubernetes dans lequel rechercher les ressources ConfigMap
spring.cloud.kubernetes.config.paths	Liste	nul	Définir le chemin de l'instance de chargement de ConfigMap
spring.cloud.kubernetes.config.enableApi	booléen	vrai	ConfigMap active ou désactive les instances d'utilisation via l'API

3.6.2 Paramètres configurables secrets

le nom du paramètre	taper	Valeurs par défaut	Paramètre Description
spring.cloud.kubernetes.secrets.enabled	booléen	vrai	Activer ou non la configuration dynamique secrète
spring.cloud.kubernetes.secrets.name	Chaîne	${spring.application.name}	Définissez le nom du secret à trouver
spring.cloud.kubernetes.secrets.espace de noms	Chaîne	Espace de noms client	Définir l'espace de noms Kubernetes à rechercher pour les ressources secrètes
spring.cloud.kubernetes.secrets.labels	Carte	nul	Définissez l'étiquette utilisée pour trouver le secret
spring.cloud.kubernetes.secrets.chemins	Liste	nul	Définissez le chemin d'installation de Secret
spring.cloud.kubernetes.secrets.enableApi	booléen	FAUX	Activer ou désactiver l'écoute de Secret via l'API

3.6.3 Recharger les paramètres configurables

le nom du paramètre	taper	Valeurs par défaut	Paramètre Description
spring.cloud.kubernetes.reload.enabled	booléen	FAUX	Démarrer la surveillance dynamique de la configuration
spring.cloud.kubernetes.reload.monitoring-config-maps	booléen	vrai	Permet de surveiller les changements dans la ConfigMap
spring.cloud.kubernetes.reload.monitoring-secrets	booléen	FAUX	Permet de surveiller les modifications secrètes
spring.cloud.kubernetes.reload.strategy	Énumération	rafraîchir	Configurez la stratégie de mise à jour : – refresh (mise à jour) – restart_context (redémarrez le conteneur Spring) – shutdown (tuez l'application pour que Kubernetes la redémarre))
spring.cloud.kubernetes.reload.mode	Énumération	événement	Spécifiez la stratégie de surveillance : – événement : mettre à jour lorsque la configuration change – interrogation : détecter périodiquement les changements de configuration pour mettre à jour la configuration
spring.cloud.kubernetes.reload.période	Durée	15s	Intervalle de détection lors de l'utilisation de la stratégie d'interrogation

quatre épreuves

Le service est déployé sous l'espace de noms springconfig

4.1 Carte de configuration

• afficher la valeur

• voir les propriétés

• voir env

Modifier le contenu du cm (  k edit cm -n springconfig springboot-config-cm ), afficher le contenu

Conclusion : la valeur utilise le mode pull et ne peut pas terminer le changement de contenu. La méthode env/properties est utilisée pour obtenir le contenu, et elle sera modifiée avec cm, et elle prendra effet en fonction de la compréhension du cycle pull.

4.2 Secrète

• afficher la valeur

• voir les propriétés

• voir env

Modifier le contenu secret (k edit secret -n springconfig springboot-config-secret)

• Conclusion : la valeur utilise le mode pull et ne peut pas terminer le changement de contenu. La méthode env/properties est utilisée pour obtenir le contenu, et elle sera modifiée avec cm, et elle prendra effet en fonction de la compréhension du cycle pull.

cinq autres

Il est toujours nécessaire de sélectionner le mode pull et la fréquence pull en fonction du scénario métier, et de redémarrer ou non le conteneur IOC pour contrôler la portée d'influence.