Tutoriel : se connecter à une instance Config Server managée pour Spring dans Azure Container Apps

Article
11/20/2024

Config Server pour Spring fournit un emplacement centralisé qui rend les données de configuration disponibles pour plusieurs applications. Dans cet article, vous apprenez à connecter une application hébergée dans Azure Container Apps à une instance Java Config Server pour Spring.

Le composant Java Config Server pour Spring utilise un référentiel GitHub comme source des paramètres de configuration. Les valeurs de configuration sont mises à la disposition de votre application conteneur via une liaison entre le composant et votre application conteneur. À mesure que les valeurs changent dans le serveur de configuration, elles circulent automatiquement vers votre application, sans que vous deviez la recompiler ou la redéployer.

Ce didacticiel vous apprend à effectuer les opérations suivantes :

Créer un composant Java Config Server pour Spring
Lier le Config Server pour Spring à votre application de conteneur
Observer les valeurs de configuration avant et après avoir connecté le serveur de configuration à votre application
Chiffrer et déchiffrer les valeurs de configuration avec une clé symétrique

Important

Ce tutoriel utilise des services qui peuvent affecter votre facture Azure. Si vous décidez de suivre les étapes pas à pas, veillez à supprimer les ressources présentées dans cet article pour éviter toute facturation inattendue.

Prérequis

Compte Azure avec un abonnement actif. Si vous n'en avez pas déjà un, vous pouvez en créer un gratuitement.
Azure CLI.

À propos de l’installation

Pendant l’exécution dans Config Server pour Spring dans Azure Container Apps, tenez compte des détails suivants :

Article	Explication
Portée	Le Config Server pour Spring s’exécute dans le même environnement que l’application de conteneur connectée.
Mise à l'échelle	Pour maintenir une source unique de vérité, le Config Server pour Spring ne se met pas à l’échelle. Les propriétés de mise à l’échelle `minReplicas` et `maxReplicas` sont toutes deux définies sur `1`.
Ressources	L’allocation des ressources de conteneur pour le Config Server pour Spring est fixe, le nombre de cœurs de CPU est de 0,5 et la taille de mémoire est 1Gi.
Tarification	La facturation Config Server pour Spring est soumise à la tarification basée sur la consommation. Les ressources consommées par les composants Java managés sont facturées aux taux actif/inactif. Vous pouvez supprimer les composants qui ne sont plus utilisés pour arrêter la facturation.
Binding	L’application de conteneur se connecte à un Config Server pour Spring via une liaison. La liaison injecte les configurations dans les variables d’environnement de l’application conteneur. Une fois la liaison établie, l’application conteneur peut lire les valeurs de configuration à partir des variables d’environnement.

Programme d’installation

Avant de commencer à utiliser une instance Config Server pour Spring, vous devez d’abord créer les ressources nécessaires.

Azure CLI
Azure portal

Exécutez les commandes suivantes pour créer votre groupe de ressources et votre environnement Container Apps.

Créez des variables pour prendre en charge la configuration de votre application. Ces valeurs sont fournies dans le cadre de cette leçon.

export LOCATION=eastus
export RESOURCE_GROUP=my-services-resource-group
export ENVIRONMENT=my-environment
export JAVA_COMPONENT_NAME=configserver
export APP_NAME=my-config-client
export IMAGE="mcr.microsoft.com/javacomponents/samples/sample-service-config-client:latest"
export URI="https://github.com/Azure-Samples/azure-spring-cloud-config-java-aca.git"

Variable	Description
`LOCATION`	Emplacement de la région Azure où vous créez votre application conteneur et votre composant Java.
`ENVIRONMENT`	Nom de l’environnement Azure Container Apps pour votre application de démonstration.
`RESOURCE_GROUP`	Nom du groupe de ressources Azure de votre application de démonstration.
`JAVA_COMPONENT_NAME`	Nom du composant Java créé pour votre application conteneur. Dans ce cas, vous créez un composant Java Config Server pour Spring.
`IMAGE`	Image conteneur utilisée dans votre application conteneur.
`URI`	Vous pouvez remplacer l'URI par l'URL de votre référentiel Git, s'il est privé, ajoutez les configurations d'authentification associées telles que `spring.cloud.config.server.git.username` et `spring.cloud.config.server.git.password`.

Se connecter à Azure avec Azure CLI.
```
az login
```

Créez un groupe de ressources.

az group create --name $RESOURCE_GROUP --location $LOCATION

Créez votre environnement d’applications conteneur.

az containerapp env create \
    --name $ENVIRONMENT \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION

Procédez comme suit pour créer chacune des ressources nécessaires pour créer une application de conteneur.

Recherchez Container Apps dans le portail Microsoft Azure, puis sélectionnez Créer.

Entrez les valeurs suivantes sous l’onglet Informations de base.

Propriété	Valeur
Abonnement	Sélectionnez votre abonnement Azure.
Groupe de ressources	Sélectionnez le lien Créer pour créer un groupe de ressources nommé my-resource-group.
Nom de l’application conteneur	Entrez my-config-client.
Source de déploiement	Sélectionnez Image conteneur.
Région	Sélectionnez la région la plus proche de vous.
Environnement Container Apps	Sélectionnez le lien Créer pour créer un environnement.

Dans la fenêtre Créer un environnement Container Apps, entrez les valeurs suivantes.

Propriété Valeur

Nom de l’environnement Entrez my-environment.

Redondance de zone Sélectionnez Désactivé.

Sélectionnez Créer, puis sélectionnez l’onglet Conteneur.

Propriété	Valeur
Nom de l’environnement	Entrez my-environment.
Redondance de zone	Sélectionnez Désactivé.

Dans l’onglet Conteneur, entrez les valeurs suivantes.

Propriété	Valeur
Nom	Entrez my-config-client.
Source de l’image	Sélectionnez Docker Hub ou d’autres registres.
Type d’image	Sélectionnez Public.
Serveur de connexion au registre	Entrez mcr.microsoft.com.
Image et étiquette	Entrez javacomponents/samples/sample-service-config-client:latest.

Sélectionnez l’onglet Entrée.

Sous l’onglet Entrée, entrez les éléments suivants et laissez les valeurs par défaut dans le reste du formulaire.

Propriété	Valeur
Entrée	Sélectionnez Enabled.
Trafic d’entrée	Sélectionnez Accepter le trafic provenant de partout.
Type d’entrée	Sélectionnez HTTP.
Port cible	Entrez 8080.

Sélectionnez Revoir + créer.

Une fois les contrôles de validation réussis, sélectionnez Créer pour créer votre application conteneur.

Cet environnement est utilisé pour héberger à la fois le composant Java Config Server pour Spring et votre application de conteneur.

Créer le composant Java Config Server pour Spring

Maintenant que vous disposez d’un environnement Container Apps, vous pouvez créer votre application de conteneur et la lier à un composant Java Config Server pour Spring. Lorsque vous liez votre application conteneur, les valeurs de configuration se synchronisent automatiquement depuis le composant Config Server vers votre application.

Azure CLI
Azure portal

Créez le composant Java Config Server pour Spring.

az containerapp env java-component config-server-for-spring create \
    --environment $ENVIRONMENT \
    --resource-group $RESOURCE_GROUP \
    --name $JAVA_COMPONENT_NAME \
    --min-replicas 1 \
    --max-replicas 1 \
    --configuration spring.cloud.config.server.git.uri=$URI

Mettez à jour le composant Java Config Server pour Spring.
```
az containerapp env java-component config-server-for-spring update \
    --environment $ENVIRONMENT \
    --resource-group $RESOURCE_GROUP \
    --name $JAVA_COMPONENT_NAME \
    --min-replicas 2 \
    --max-replicas 2 \
    --configuration spring.cloud.config.server.git.uri=$URI spring.cloud.config.server.git.refresh-rate=60
```
Ici, vous indiquez au composant où trouver le référentiel qui contient vos informations de configuration via la propriété uri. La propriété refresh-rate indique aux applications conteneurisées à quelle fréquence vérifier les modifications dans votre référentiel Git.

Maintenant que vous disposez d’une application de conteneur cliente Config Server et d’un environnement, vous pouvez créer une instance de composant Java de Config Server pour Spring.

Accédez à l’environnement de votre application de conteneur dans le portail.
Dans le menu de navigation, sous la catégorie Services, sélectionnez Services.
Sélectionnez la liste déroulante Configurer et sélectionnez Composant Java.
Dans le panneau Configurer un composant Java, entrez les valeurs suivantes.

Propriété Valeur

Type de composant Java Sélectionnez Config Server pour Spring.

Nom du composant Java Entrez configserver.
Dans la section Référentiels Git, sélectionnez Ajouter, puis saisissez les valeurs suivantes :

Propriété Valeur

Type Sélectionnez HTTP.

URI Saisissez https://github.com/Azure-Samples/azure-spring-cloud-config-java-aca.git.

Laissez le reste des champs avec les valeurs par défaut, puis sélectionnez Ajouter.
Cliquez sur Suivant.
Dans l’onglet Vérifier, sélectionnez Configurer.

Propriété	Valeur
Type de composant Java	Sélectionnez Config Server pour Spring.
Nom du composant Java	Entrez configserver.

Propriété	Valeur
Type	Sélectionnez HTTP.
URI	Saisissez https://github.com/Azure-Samples/azure-spring-cloud-config-java-aca.git.

Lier votre application de conteneur au composant Java Config Server pour Spring

Azure CLI
Azure portal

Créer l’application conteneur qui consomme les données de configuration.
```
az containerapp create \
    --name $APP_NAME \
    --resource-group $RESOURCE_GROUP \
    --environment $ENVIRONMENT \
    --image $IMAGE \
    --min-replicas 1 \
    --max-replicas 1 \
    --ingress external \
    --target-port 8080 \
    --query properties.configuration.ingress.fqdn
```
Cette commande retourne l’URL de votre application conteneur qui consomme les données de configuration. Copiez l’URL dans un éditeur de texte afin de pouvoir l’utiliser dans une prochaine étape.

Si vous consultez votre application dans un navigateur, la valeur connectTimeout retournée est la valeur par défaut de 0.
Liez au Config Server pour Spring.

Maintenant que l’application conteneur et le Config Server sont créés, vous les liez avec la commande update à votre application conteneur.
```
az containerapp update \
    --name $APP_NAME \
    --resource-group $RESOURCE_GROUP \
    --bind $JAVA_COMPONENT_NAME
```
Le paramètre --bind $JAVA_COMPONENT_NAME crée la liaison entre votre application conteneur et le composant de configuration.

Une fois l’application conteneur et le composant Config Server liés, les modifications de configuration sont automatiquement synchronisées avec l’application conteneur.

Si vous vous rendez à nouveau sur l’URL de l’application, la valeur connectTimeout est maintenant 10000. Cette valeur provient du référentiel Git défini dans la variable $URI initialement définie comme source du composant de configuration. Plus précisément, cette valeur est extraite de la propriété connectionTimeout dans le fichier application.yml du référentiel.

La demande de liaison injecte le paramètre de configuration dans l’application en tant que variables d’environnement. Ces valeurs sont désormais disponibles pour être utilisées par le code de l’application lors de l’extraction des paramètres de configuration depuis le serveur de configuration.

Dans ce cas, les variables d’environnement suivantes sont disponibles pour l’application :

SPRING_CLOUD_CONFIG_URI=http://[JAVA_COMPONENT_INTERNAL_FQDN]:80
SPRING_CLOUD_CONFIG_COMPONENT_URI=http://[JAVA_COMPONENT_INTERNAL_FQDN]:80
SPRING_CONFIG_IMPORT=optional:configserver:$SPRING_CLOUD_CONFIG_URI

Si vous souhaitez personnaliser votre propre SPRING_CONFIG_IMPORT, vous pouvez vous référer à la variable d'environnement SPRING_CLOUD_CONFIG_COMPONENT_URI - par exemple, vous pouvez remplacer par des arguments de ligne de commande, comme Java -Dspring.config.import=optional:configserver:${SPRING_CLOUD_CONFIG_COMPONENT_URI}?fail-fast=true.

Vous pouvez également supprimer une liaison de votre application.

(Facultatif) Dissocier votre application conteneur à partir du composant Java Config Server pour Spring

Azure CLI
Azure portal

Pour supprimer une liaison d’une application conteneur, utilisez l’option --unbind.

az containerapp update \
    --name $APP_NAME \
    --unbind $JAVA_COMPONENT_NAME \
    --resource-group $RESOURCE_GROUP

Si vous vous rendez à nouveau sur l’URL de l’application, la valeur de connectTimeout revient à 0.

Nettoyer les ressources

Les ressources créées dans ce tutoriel ont un effet sur votre facture Azure. Si vous n’allez pas utiliser ces services à long terme, exécutez la commande suivante pour supprimer tout ce qui a été créé dans ce didacticiel.

az group delete --resource-group $RESOURCE_GROUP

Options de configuration

La commande az containerapp update utilise le paramètre --configuration pour contrôler la configuration du Config Server pour Spring. Vous pouvez utiliser plusieurs paramètres à la fois tant qu’ils sont séparés par un espace. Pour plus d'informations, consultez Spring Cloud Config Server.

Le tableau suivant décrit les différentes valeurs de configuration du backend Git disponibles :

Nom	Description
`spring.cloud.config.server.git.uri` `spring.cloud.config.server.git.repos.{repoName}.uri`	URI du référentiel distant.
`spring.cloud.config.server.git.username` `spring.cloud.config.server.git.repos.{repoName}.username`	Nom d’utilisateur pour l’authentification avec le référentiel distant.
`spring.cloud.config.server.git.password` `spring.cloud.config.server.git.repos.{repoName}.password`	Mot de passe pour l’authentification avec le référentiel distant.
`spring.cloud.config.server.git.search-paths` `spring.cloud.config.server.git.repos.{repoName}.search-paths`	Chemins de recherche à utiliser dans la copie de travail locale. Par défaut, recherche uniquement la racine.
`spring.cloud.config.server.git.force-pull` `spring.cloud.config.server.git.repos.{repoName}.force-pull`	Indicateur pour indiquer que le référentiel doit forcer l’extraction. Si `true`, ignorez toutes les modifications locales et récupérez-les à partir du référentiel distant.
`spring.cloud.config.server.git.default-label` `spring.cloud.config.server.git.repos.{repoName}.default-label`	L'étiquette par défaut utilisée pour Git est principale. Si vous ne définissez pas `spring.cloud.config.server.git.default-label` et qu'une branche nommée principale n'existe pas, le serveur de configuration essaie également par défaut d'extraire une branche nommée master. Si vous souhaitez désactiver le comportement de la branche de secours, vous pouvez définir `spring.cloud.config.server.git.tryMasterBranch` sur `false`.
`spring.cloud.config.server.git.try-master-branch` `spring.cloud.config.server.git.repos.{repoName}.try-master-branch`	Le serveur de configuration essaie par défaut d'extraire une branche nommée master.
`spring.cloud.config.server.git.skip-ssl-validation` `spring.cloud.config.server.git.repos.{repoName}.skip-ssl-validation`	Vous pouvez désactiver la validation du certificat TLS/SSL du serveur Git par le serveur de configuration en définissant la propriété `git.skipSslValidation` sur `true`.
`spring.cloud.config.server.git.clone-on-start` `spring.cloud.config.server.git.repos.{repoName}.clone-on-start`	Drapeau pour indiquer que le référentiel doit être cloné au démarrage et non à la requête. Entraîne généralement un démarrage est plus lent, mais une première requête plus rapide.
`spring.cloud.config.server.git.timeout` `spring.cloud.config.server.git.repos.{repoName}.timeout`	Délai d'expiration en secondes pour l'obtention d'une connexion HTTP ou SSH, le cas échéant. La valeur par défaut est 5 secondes.
`spring.cloud.config.server.git.refresh-rate` `spring.cloud.config.server.git.repos.{repoName}.refresh-rate`	Fréquence à laquelle le serveur de configuration récupère les données de configuration mises à jour depuis votre back-end Git.
`spring.cloud.config.server.git.private-key` `spring.cloud.config.server.git.repos.{repoName}.private-key`	Clé privée SSH valide. Doit être défini si `ignore-local-ssh-settings` est `true` et que l'URI Git est au format SSH.
`spring.cloud.config.server.git.host-key` `spring.cloud.config.server.git.repos.{repoName}.host-key`	Clé d’hôte SSH valide. Doit être défini si `host-key-algorithm` est également défini.
`spring.cloud.config.server.git.host-key-algorithm` `spring.cloud.config.server.git.repos.{repoName}.host-key-algorithm`	L’un parmi `ssh-dss`, `ssh-rsa`, `ssh-ed25519`, `ecdsa-sha2-nistp256`, `ecdsa-sha2-nistp384` ou `ecdsa-sha2-nistp521`. Doit être défini si `host-key` est également défini.
`spring.cloud.config.server.git.strict-host-key-checking` `spring.cloud.config.server.git.repos.{repoName}.strict-host-key-checking`	`true` ou `false`. Si `false`, ignorez les erreurs avec la clé d’hôte.
`spring.cloud.config.server.git.repos.{repoName}`	URI du référentiel distant.
`spring.cloud.config.server.git.repos.{repoName}.pattern`	Le format du modèle est une liste de noms séparés par des virgules `{application}/{profile}` avec des caractères génériques. Si `{application}/{profile}` ne correspond à aucun des modèles, il utilise l'URI par défaut défini ci-dessous.

La liste suivante décrit les configurations courantes :

Configurations relatives à la journalisation :
- logging.level.*
- logging.group.*
- Toute autre configuration sous l'espace de noms logging.* doit être interdite - par exemple, l'écriture de fichiers journaux en utilisant logging.file doit être interdite.
spring.cloud.config.server.overrides
- Carte supplémentaire pour qu’une source de propriété soit envoyée à tous les clients sans condition.
spring.cloud.config.override-none
- Vous pouvez modifier la priorité de tous les remplacements dans le client pour qu'elle ressemble davantage aux valeurs par défaut, en permettant aux applications de fournir leurs propres valeurs dans les variables d'environnement ou les propriétés système, en définissant l'indicateur spring.cloud.config.override-none=true - la valeur par défaut est false - dans le référentiel distant.
spring.cloud.config.allow-override
- Si vous activez la configuration au premier démarrage, vous pouvez autoriser les applications clientes à remplacer la configuration du serveur de configuration en plaçant deux propriétés dans la configuration des applications provenant du serveur de configuration.
spring.cloud.config.server.health.*
- Vous pouvez configurer l'indicateur de santé pour vérifier davantage d'applications ainsi que des profils personnalisés et des étiquettes personnalisées.
spring.cloud.config.server.accept-empty
- Vous pouvez configurer spring.cloud.config.server.accept-empty sur false de manière à ce que le serveur renvoie un statut HTTP 404 si l'application n'est pas trouvée. Par défaut, cet indicateur est défini sur true.
Cryptage et décryptage (symétrique) :
- encrypt.key
  - Pratique lorsque vous utilisez une clé symétrique car il s'agit d'une valeur de propriété unique à configurer.
- spring.cloud.config.server.encrypt.enabled
  - Définissez cette propriété sur false pour désactiver le décryptage côté serveur.

Actualiser

Les services qui consomment des propriétés doivent être informés d’un changement avant qu’il ne se produise. La méthode de notification par défaut pour Config Server pour Spring implique le déclenchement manuel de l'événement d'actualisation, comme une actualisation par appel https://<YOUR_CONFIG_CLIENT_HOST_NAME>/actuator/refresh, ce qui peut ne pas être possible s'il existe de nombreuses instances d'application.

À la place, vous pouvez actualiser automatiquement les valeurs de Config Server en laissant le client de configuration interroger les modifications en fonction d’une actualisation interne. Procédez comme suit pour actualiser automatiquement les valeurs à partir du serveur de configuration :

Inscrivez une tâche planifiée pour actualiser le contexte dans un intervalle donné, comme illustré dans l’exemple suivant :

@Configuration
@AutoConfigureAfter({RefreshAutoConfiguration.class, RefreshEndpointAutoConfiguration.class})
@EnableScheduling
public class ConfigClientAutoRefreshConfiguration implements SchedulingConfigurer {
    @Value("${spring.cloud.config.refresh-interval:60}")
    private long refreshInterval;
    @Value("${spring.cloud.config.auto-refresh:false}")
    private boolean autoRefresh;
    private final RefreshEndpoint refreshEndpoint;
    public ConfigClientAutoRefreshConfiguration(RefreshEndpoint refreshEndpoint) {
        this.refreshEndpoint = refreshEndpoint;
    }
    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        if (autoRefresh) {
            // set minimal refresh interval to 5 seconds
            refreshInterval = Math.max(refreshInterval, 5);
            scheduledTaskRegistrar.addFixedRateTask(refreshEndpoint::refresh,  Duration.ofSeconds(refreshInterval));
        }
    }
}

Activez autorefresh et définissez l’intervalle d’actualisation approprié dans le fichier application.yml. Dans l’exemple suivant, le client cherche une modification de configuration toutes les 60 secondes, ce qui correspond à la valeur minimale que vous pouvez définir pour un intervalle d’actualisation.

Par défaut, autorefresh est réglé sur false et refresh-interval est réglé sur 60 secondes.
```
spring:
    cloud:
        config:
        auto-refresh: true
        refresh-interval: 60
management:
    endpoints:
        web:
        exposure:
            include:
            - refresh
```
Ajoutez @RefreshScope dans votre code. Dans l'exemple suivant, la variable connectTimeout est automatiquement actualisée toutes les 60 secondes :
```
@RestController
@RefreshScope
public class HelloController {
    @Value("${timeout:4000}")
    private String connectTimeout;
}
```

Chiffrement et déchiffrement avec une clé asymétrique

Déchiffrement côté serveur

Par défaut, le chiffrement côté serveur est activé. Suivez les étapes suivantes pour activer le déchiffrement dans votre application :

Ajoutez la propriété chiffrée dans votre fichier .properties dans votre référentiel Git.

Le fichier doit ressembler à l’exemple suivant :
```
message={cipher}f43e3df3862ab196a4b367624a7d9b581e1c543610da353fbdd2477d60fb282f
```
Mettez à jour le composant Java Config Server pour Spring pour utiliser le référentiel Git qui possède la propriété cryptée et définissez la clé de chiffrement.

Avant d’exécuter la commande suivante, remplacez les espaces réservés entourés par <> par vos valeurs.
```
az containerapp env java-component config-server-for-spring update \
    --environment <ENVIRONMENT_NAME> \
    --resource-group <RESOURCE_GROUP> \
    --name <JAVA_COMPONENT_NAME> \
    --configuration spring.cloud.config.server.git.uri=<URI> encrypt.key=randomKey
```

Déchiffrement côté client

Vous pouvez utiliser le déchiffrement côté client des propriétés en procédant comme suit :

Ajoutez la propriété chiffrée dans votre fichier .properties dans votre référentiel Git.

Mettez à jour le composant Java Config Server pour Spring pour utiliser le référentiel Git doté de la propriété cryptée et désactiver le décryptage côté serveur.

Avant d’exécuter la commande suivante, remplacez les espaces réservés entourés par <> par vos valeurs.

az containerapp env java-component config-server-for-spring update \
    --environment <ENVIRONMENT_NAME> \
    --resource-group <RESOURCE_GROUP> \
    --name <JAVA_COMPONENT_NAME> \
    --configuration spring.cloud.config.server.git.uri=<URI> spring.cloud.config.server.encrypt.enabled=false

Dans votre application cliente, ajoutez la clé de déchiffrement ENCRYPT_KEY=randomKey comme une variable d’environnement.

Alternativement, si vous incluez spring-cloud-starter-bootstrap sur le classpath, ou définissez spring.cloud.bootstrap.enabled=true comme propriété système, définissez encrypt.key dans bootstrap.properties.

Avant d’exécuter la commande suivante, remplacez les espaces réservés entourés par <> par vos valeurs.
```
az containerapp update \
    --name <APP_NAME> \
    --resource-group <RESOURCE_GROUP> \
    --set-env-vars "ENCRYPT_KEY=randomKey"
```
```
encrypt:
  key: somerandomkey
```

Partager via