Se connecter à une administration gérée pour Spring dans Azure Container Apps

Le composant administration gérée pour Spring offre une interface d’administration pour les applications web Spring Boot qui exposent des points de terminaison d’actionneur. En tant que composant managé dans Azure Container Apps, vous pouvez facilement lier votre application conteneur à administration pour Spring pour une intégration et une gestion transparentes.

Ce tutoriel vous montre comment créer un composant Java Administration pour Spring et le lier à votre application conteneur afin de pouvoir surveiller et gérer facilement vos applications Spring.

Dans ce tutoriel, vous allez apprendre à :

Créez un composant Java Administration pour Spring.
Liez votre application conteneur à un composant Java Administration pour Spring.

Si vous souhaitez intégrer Administration pour Spring à un serveur Eureka pour Spring, consultez plutôt Intégrer Administration pour Spring à un serveur Eureka pour Spring dans Azure Container Apps.

Important

Ce tutoriel utilise des services qui peuvent affecter votre facture Azure. Si vous décidez de suivre les étapes, assurez-vous de 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à, vous pouvez en créer un gratuitement.
Azure CLI.

Considérations

Lorsque vous exécutez le composant Administration pour Spring dans Container Apps, tenez compte des détails suivants :

Élément	Explication
Étendue	Les composants s’exécutent dans le même environnement que l’application conteneur connectée.
Mise à l'échelle	Les composants ne peuvent pas être mis à 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 les composants est fixe. Le nombre de cœurs de processeur est de 0,5 et la taille de la mémoire est de 1 Go.
Tarifs	La facturation des composants est soumise à des tarifs basés sur la consommation. Les ressources consommées par les composants managés sont facturées aux taux actifs ou inactifs, en fonction de l’utilisation des ressources. Vous pouvez supprimer les composants qui ne sont plus utilisés pour arrêter la facturation.
Liaison	Les applications conteneur se connectent à un composant 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 et se connecter au composant.

Programme d’installation

Avant de commencer à utiliser le composant Admin for Spring, vous devez créer les ressources requises.

Azure CLI
portail Azure

Les commandes suivantes vous aident à créer votre groupe de ressources et l’environnement de votre application conteneur.

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-resource-group
export ENVIRONMENT=my-environment
export JAVA_COMPONENT_NAME=admin
export APP_NAME=sample-admin-client
export IMAGE="mcr.microsoft.com/javacomponents/samples/sample-admin-for-spring-client:latest"

Variable	Description
`LOCATION`	Localisation de la région Azure où vous créez votre application conteneur et votre composant Java.
`ENVIRONMENT`	Le nom de l’environnement d’application conteneur pour votre application de démonstration.
`RESOURCE_GROUP`	Nom du groupe de ressources Azure pour votre application de démo.
`JAVA_COMPONENT_NAME`	Nom du composant Java créé pour votre application conteneur. Dans ce cas, vous créez un(e) administrateur(-trice) composant Java pour Spring.
`IMAGE`	Image conteneur utilisée dans votre application conteneur.

Se connecter à Azure avec Azure CLI.
```
az login
```
Créez un groupe de ressources.
```
az group create \
    --name $RESOURCE_GROUP \
    --location $LOCATION \
    --query "properties.provisioningState"
```
Lorsque vous utilisez le paramètre --query, la réponse filtre jusqu’à un simple message de succès ou d’échec.

Créez l’environnement de votre application conteneur.

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

Pour créer chacune des ressources nécessaires pour créer une application conteneur, procédez comme suit :

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

Sous l’onglet Informations de base, entrez les valeurs suivantes :

Propriété	Valeur
Abonnement	Sélectionnez votre abonnement Azure.
groupe de ressources	Sélectionnez Créer pour créer un groupe de ressources appelé `my-resource-group`.
Nom de l’application conteneur	Entrez sample-admin-client.
Source de déploiement	Sélectionnez Image conteneur.
Région	Sélectionnez la région la plus proche de vous.
Environnement d’application conteneur	Sélectionnez Créer pour créer un environnement.

Dans la fenêtre Créer un environnement Applications conteneur, 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é.

Sous l’onglet Conteneur, entrez les valeurs suivantes :

Propriété	Valeur
Nom	Entrez sample-admin-client.
Source d’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-admin-for-spring-client:latest.

Sélectionnez l’onglet Entrée.

Sous l’onglet Entrée, entrez les valeurs suivantes 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.

Maintenant que vous avez un environnement existant, vous pouvez créer votre application conteneur et la lier à l’instance du composant Java Administration pour Spring.

Créez le composant Java Administration pour Spring.

az containerapp env java-component admin-for-spring create \
    --environment $ENVIRONMENT \
    --resource-group $RESOURCE_GROUP \
    --name $JAVA_COMPONENT_NAME \
    --min-replicas 1 \
    --max-replicas 1

Mettez à jour le composant Java Administration pour Spring.

az containerapp env java-component admin-for-spring update \
    --environment $ENVIRONMENT \
    --resource-group $RESOURCE_GROUP \
    --name $JAVA_COMPONENT_NAME \
    --min-replicas 2 \
    --max-replicas 2

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

Accédez à l’environnement de votre application de conteneur dans le portail.
Dans le menu du service, sous Services, sélectionnez Services.
Sélectionnez la liste déroulante Configurer, puis Composant Java.
Dans le volet Configurer un composant Java, entrez les valeurs suivantes :

Propriété Valeur

Type de composant Java Utiliser l’administration pour Spring.

Nom du composant Java Entrez admin.
Sélectionnez Suivant.
Dans l’onglet Vérifier, sélectionnez Configurer.

Propriété	Valeur
Type de composant Java	Utiliser l’administration pour Spring.
Nom du composant Java	Entrez admin.

Lier votre application conteneur au composant Java de l’administration pour Spring

Azure CLI
portail Azure

Créez l’application conteneur et liez-la au composant Administration pour Spring.

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 \
    --bind $JAVA_COMPONENT_NAME

L’opération de liaison connecte l’application conteneur au composant Admin pour Spring Java. L’application conteneur peut maintenant lire les valeurs de configuration des variables d’environnement, en particulier la propriété SPRING_BOOT_ADMIN_CLIENT_URL, et se connecter au composant Administration pour Spring.

La liaison injecte aussi la propriété suivante :

"SPRING_BOOT_ADMIN_CLIENT_INSTANCE_PREFER-IP": "true",

Cette propriété indique que le client de composant Admin pour Spring doit utiliser l’adresse IP de l’instance d’application conteneur lorsque vous vous connectez à l’administrateur pour le serveur Spring.

Facultatif : dissociez votre application conteneur du composant Java Administration pour Spring

Azure CLI
portail Azure

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

Afficher le tableau de bord

Important

Pour afficher le tableau de bord, votre compte a besoin au moins du Microsoft.App/managedEnvironments/write rôle sur la ressource d’environnement managé. Vous pouvez attribuer explicitement le rôle Owner ou Contributor sur la ressource. Vous pouvez également suivre les étapes pour créer une définition de rôle personnalisé et l’attribuer à votre compte.

Remarque

Le tableau de bord n’est pas disponible dans Azure géré par 21Vianet.

Créez la définition de rôle personnalisé.

az role definition create --role-definition '{
    "Name": "<ROLE_NAME>",
    "IsCustom": true,
    "Description": "Can access managed Java Component dashboards in managed environments",
    "Actions": [
        "Microsoft.App/managedEnvironments/write"
    ],
    "AssignableScopes": ["/subscriptions/<SUBSCRIPTION_ID>"]
}'

Veillez à remplacer les espaces réservés entre les crochets <> par vos valeurs.

Attribuez le rôle personnalisé à votre compte sur la ressource d’environnement managé.

Obtenez l’ID de ressource de l’environnement managé :
```
export ENVIRONMENT_ID=$(az containerapp env show \
    --name $ENVIRONMENT --resource-group $RESOURCE_GROUP \ 
    --query id \
    --output tsv)
```
Attribuez le rôle à votre compte.

Avant d’exécuter cette commande, remplacez l’espace réservé (indiqué par des crochets <>) par votre ID d’utilisateur ou de principal de service ou le nom du rôle.
```
az role assignment create \
    --assignee <USER_OR_SERVICE_PRINCIPAL_ID> \
    --role "<ROLE_NAME>" \
    --scope $ENVIRONMENT_ID
```
Remarque

La valeur <USER_OR_SERVICE_PRINCIPAL_ID> doit être l’identité que vous utilisez pour accéder au portail Azure. La valeur <ROLE_NAME> est le nom que vous avez attribué à l’étape 1.
Obtenez l’URL du tableau de bord Administration pour Spring.
```
az containerapp env java-component admin-for-spring show \
    --environment $ENVIRONMENT \
    --resource-group $RESOURCE_GROUP \
    --name $JAVA_COMPONENT_NAME \
    --query properties.ingress.fqdn \
    --output tsv
```
Cette commande retourne l’URL que vous pouvez utiliser pour accéder au tableau de bord Administration pour Spring. Avec le tableau de bord, vous pouvez également afficher votre application conteneur, comme illustré dans la capture d’écran suivante.

Nettoyer les ressources

Les ressources que vous créez dans ce tutoriel affectent votre facture Azure. Si vous ne prévoyez pas d’utiliser ces services à long terme, exécutez la commande suivante pour supprimer tout ce que vous avez créé dans ce didacticiel.

az group delete --resource-group $RESOURCE_GROUP

Dépendance

Lorsque vous utilisez le composant administrateur dans votre propre application conteneur, ajoutez la dépendance suivante dans votre fichier pom.xml . Remplacez le numéro de version par la dernière version disponible sur le référentiel Maven.

<dependency>
    <groupId>de.codecentric</groupId>
    <version>3.3.2</version>
    <artifactId>spring-boot-admin-starter-client</artifactId>
</dependency>

Remarque

Vous n’avez pas besoin d’ajouter la dépendance du client de démarrage d’administrateur pour Spring Boot Admin si vous activez l’agent Java dans votre application conteneur en exécutant la commande suivante dans Azure CLI :

az containerapp update --enable-java-agent \
--resource-group $RESOURCE_GROUP \
--name $APP_NAME

Propriétés configurables

À compter de Spring Boot 2, les points de terminaison autres que health et info ne sont pas exposés par défaut. Vous pouvez les exposer en ajoutant la configuration suivante dans votre fichier application.properties.

management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

Liste de configurations autorisées pour votre composant Administration pour Spring

La liste suivante détaille les propriétés du composant Administration que vous pouvez configurer pour votre application. Pour plus d’informations, consultez Spring Boot Admin.

Nom de la propriété	Description	Valeur par défaut
`spring.boot.admin.server.enabled`	Active le serveur Spring Boot Admin.	`true`
`spring.boot.admin.context-path`	Préfixe de chemin d’accès où les ressources statiques et l’API du serveur d’administration sont traitées. Relativement à Dispatcher-Servlet.
`spring.boot.admin.monitor.status-interval`	Intervalle de vérification de l’état des instances en millisecondes.	`10,000ms`
`spring.boot.admin.monitor.status-lifetime`	Durée de vie de l’état en millisecondes. L’état n’est pas mis à jour tant que le dernier état n’a pas expiré.	10 000 ms
`spring.boot.admin.monitor.info-interval`	Intervalle de vérification des informations des instances en millisecondes.	`1m`
`spring.boot.admin.monitor.info-lifetime`	Durée de vie des informations en minutes. Les informations ne sont pas mises à jour tant que les dernières informations n’ont pas expiré.	`1m`
`spring.boot.admin.monitor.default-timeout`	Délai d’expiration par défaut lors de l’exécution de requêtes. Vous pouvez remplacer les valeurs individuelles de points de terminaison spécifiques avec `spring.boot.admin.monitor.timeout.*`.	`10,000`
`spring.boot.admin.monitor.timeout.*`	Paires clé-valeur avec le délai d’expiration par `endpointId`.	Prend par défaut la valeur `default-timeout`.
`spring.boot.admin.monitor.default-retries`	Nombre de nouvelles tentatives par défaut pour les requêtes ayant échoué. Les demandes qui modifient les données (`PUT`, `POST`, `PATCH`, `DELETE`) ne sont pas réessayées. Vous pouvez remplacer les valeurs individuelles de points de terminaison spécifiques avec `spring.boot.admin.monitor.retries.*`.	`0`
`spring.boot.admin.monitor.retries.*`	Paires clé-valeur avec le nombre de nouvelles tentatives par `endpointId`. Les demandes qui modifient les données (`PUT`, `POST`, `PATCH`, `DELETE`) ne sont pas réessayées.	Prend par défaut la valeur `default-retries`.
`spring.boot.admin.metadata-keys-to-sanitize`	Valeurs de métadonnées pour les clés correspondant aux modèles regex utilisés pour assainir toutes les sorties JSON. À compter de Spring Boot 3, toutes les valeurs d’actionneur sont masquées par défaut. Pour plus d’informations sur la configuration du processus de non-assainissement, consultez Assainir les valeurs sensibles.	`".password$", ".secret$", ".key$", ".token$", ".credentials.", ".*vcap_services$"`
`spring.boot.admin.probed-endpoints`	Pour les applications clientes Spring Boot 1.x, Spring Boot Admin sonde les points de terminaison spécifiés à l’aide d’une `OPTIONS` requête. Si le chemin d’accès diffère de l’ID, vous pouvez spécifier cette valeur en tant que `id:path` (par exemple, `health:ping`).	`"health", "env", "metrics", "httptrace:trace", "threaddump:dump", "jolokia", "info", "logfile", "refresh", "flyway", "liquibase", "heapdump", "loggers", "auditevents"`
`spring.boot.admin.instance-proxy.ignored-headers`	En-têtes à ne pas transférer dans le cadre de requêtes adressées aux clients.	`"Cookie", "Set-Cookie", "Authorization"`
`spring.boot.admin.ui.title`	Titre de page affiché.	`"Spring Boot Admin"`
`spring.boot.admin.ui.poll-timer.cache`	Durée d’interrogation en millisecondes pour extraire les nouvelles données de cache.	`2500`
`spring.boot.admin.ui.poll-timer.datasource`	Durée d’interrogation en millisecondes pour extraire les nouvelles données de source de données.	`2500`
`spring.boot.admin.ui.poll-timer.gc`	Durée d’interrogation en millisecondes pour extraire les nouvelles données gc.	`2500`
`spring.boot.admin.ui.poll-timer.process`	Durée d’interrogation en millisecondes pour extraire les nouvelles données de processus.	`2500`
`spring.boot.admin.ui.poll-timer.memory`	Durée d’interrogation en millisecondes pour extraire les nouvelles données de mémoire.	`2500`
`spring.boot.admin.ui.poll-timer.threads`	Durée d’interrogation en millisecondes pour extraire les nouvelles données de threads.	`2500`
`spring.boot.admin.ui.poll-timer.logfile`	Durée d’interrogation en millisecondes pour extraire les nouvelles données de fichier journal.	`1000`
`spring.boot.admin.ui.enable-toasts`	Active ou désactive les notifications toast.	`false`
`spring.boot.admin.ui.title`	Valeur de titre de la fenêtre du navigateur.	""
`spring.boot.admin.ui.brand`	Code HTML affiché dans l’en-tête de navigation. Il s’agit par défaut de l’étiquette Spring Boot Admin. Par défaut, le logo de Spring Boot Admin est suivi de son nom.	""
`management.scheme`	Valeur remplacée dans l’URL de service utilisée pour accéder aux points de terminaison d’actionneur.
`management.address`	Valeur remplacée dans l’URL de service utilisée pour accéder aux points de terminaison d’actionneur.
`management.port`	Valeur remplacée dans l’URL de service utilisée pour accéder aux points de terminaison d’actionneur.
`management.context-path`	Valeur ajoutée à l’URL de service utilisée pour accéder aux points de terminaison d’actionneur.	`${spring.boot.admin.discovery.converter.management-context-path}`
`health.path`	Valeur ajoutée à l’URL de service utilisée pour la vérification de l’intégrité. Ignorée par le `EurekaServiceInstanceConverter`.	`${spring.boot.admin.discovery.converter.health-endpoint}`
`spring.boot.admin.discovery.enabled`	Active la prise en charge de `DiscoveryClient` pour le serveur Admin.	`true`
`spring.boot.admin.discovery.converter.management-context-path`	Valeur ajoutée à `service-url` du service découvert lorsque la valeur `management-url` est convertie par `DefaultServiceInstanceConverter`.	`/actuator`
`spring.boot.admin.discovery.converter.health-endpoint-path`	Valeur ajoutée à `management-url` du service découvert lorsque la valeur `health-url` est convertie par `DefaultServiceInstanceConverter`.	`"health"`
`spring.boot.admin.discovery.ignored-services`	Services ignorés lors de l’utilisation de la découverte et non inscrits en tant qu’application. Prend en charge des modèles simples tels que `"foo"`, `"bar"` et `"foobar"`.
`spring.boot.admin.discovery.services`	Services inclus lors de l’utilisation de la découverte et inscrits en tant qu’application. Prend en charge des modèles simples tels que `"foo"`, `"bar"` et `"foobar"`.	`"*"`
`spring.boot.admin.discovery.ignored-instances-metadata`	Services ignorés s’ils contiennent au moins un élément de métadonnées qui correspond aux modèles de cette liste. Prend en charge des modèles tels que `"discoverable=false"`.
`spring.boot.admin.discovery.instances-metadata`	Services inclus s’ils contiennent au moins un élément de métadonnées qui correspond aux modèles de la liste. Prend en charge des modèles tels que `"discoverable=true"`.

Configurations courantes

Configurations relatives à la journalisation :
- logging.level.*
- logging.group.*
- Toutes les autres configurations sous le namespace logging.*. Par exemple, n’utilisez logging.file pas pour écrire des fichiers journaux.

Limites

Le tableau de bord de l’administrateur Spring Boot n’est pas disponible dans Azure géré par 21Vianet.

Intégrer l’Administration gérée pour Spring à Serveur Eureka pour Spring

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-11-07