Tutoriel : Se connecter à un service Azure Cache pour Redis dans Azure Container Apps (préversion)

Article
06/13/2023

Azure Container Apps vous permet de vous connecter à des services qui prennent en charge votre application qui s’exécute dans le même environnement que votre application conteneur.

En cours de développement, votre application peut rapidement créer et se connecter à des services de développement. Ces services sont faciles à créer et sont des services au niveau du développement conçus pour les environnements de non-production.

Au moment de passer en production, votre application peut connecter des services gérés au niveau de la production.

Ce tutoriel vous montre comment connecter un service Azure Cache pour Redis de niveau développement et production à votre application conteneur.

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

Créer un nouveau service de développement Redis
Connecter une application conteneur au service de développement Redis
Déconnecter le service de l’application
Inspecter le service exécutant un cache en mémoire

Prérequis

Ressource	Description
Compte Azure	Un abonnement actif est requis. Si vous n’en avez pas, vous pouvez en créer un gratuitement.
Azure CLI	Installez l’Azure CLI si elle n’est pas installée sur votre ordinateur.
Groupe de ressources Azure	Créez un groupe de ressources nommé my-services-resource-group dans la région USA Est.
Cache Azure pour Redis	Créez une instance de Azure Cache pour Redis dans le groupe de ressources my-services-resource-group.

Configurer

Se connecter à Azure CLI.
```
az login
```
Mettez à niveau l’extension de l’interface CLI Container Apps.
```
az extension add --name containerapp --upgrade
```

Enregistrez l’espace de noms Microsoft.App.

az provider register --namespace Microsoft.App

Enregistrez l’espace de noms Microsoft.ServiceLinker.

az provider register --namespace Microsoft.ServiceLinker

Configurer la variable de groupe de ressources
```
RESOURCE_GROUP="my-services-resource-group"
```
Créez une variable pour le nom DNS Azure Cache pour Redis.

Pour afficher la liste des instances Azure Cache pour Redis, exécutez la commande suivante :
```
az redis list --resource-group "$RESOURCE_GROUP" --query "[].name" -o table
```
Créez une variable pour conserver votre nom d’environnement.

Remplacez <MY_ENVIRONMENT_NAME> par le nom de votre environnement d’applications conteneur.
```
ENVIRONMENT=<MY_ENVIRONMENT_NAME>
```
Configurez la variable d’emplacement.
```
LOCATION="eastus"
```

Créez un environnement.

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

Maintenant que l’interface CLI est configurée et qu’un environnement a été créé, vous pouvez créer une application et un service de développement.

Créer un service de développement

L’exemple d’application gère un ensemble de chaînes, que ce soit en mémoire ou dans le cache Redis.

Créez le service de développement Redis et nommez-le myredis.

az containerapp add-on redis create \
  --name myredis \
  --resource-group "$RESOURCE_GROUP" \
  --environment "$ENVIRONMENT"

Créer une application de conteneur

Ensuite, créez votre application de conteneur accessible par internet.

Créez une application conteneur et liez-la au service Redis.
```
az containerapp create \
  --name myapp \
  --image mcr.microsoft.com/k8se/samples/sample-service-redis:latest \
  --ingress external \
  --target-port 8080 \
  --bind myredis \
  --environment "$ENVIRONMENT" \
  --resource-group "$RESOURCE_GROUP" \
  --query properties.configuration.ingress.fqdn
```
Cette commande retourne le nom de domaine complet (FQDN). Collez cet emplacement dans un navigateur web afin de pouvoir inspecter le comportement de l’application au cours de ce tutoriel.

La commande containerapp create utilise l’option --bind pour créer un lien entre l’application conteneur et le service de développement Redis.

La demande de liaison collecte les informations de connexion, y compris les informations d’identification et les chaînes de connexion, et les injecte dans l’application en tant que variables d’environnement. Ces valeurs sont désormais disponibles pour le code d’application à utiliser afin de créer une connexion au service.

Dans ce cas, les variables d’environnement suivantes sont disponibles pour l’application :
```
REDIS_ENDPOINT=myredis:6379
REDIS_HOST=myredis
REDIS_PASSWORD=...
REDIS_PORT=6379
```
Si vous accédez à l’application à l’aide d’un navigateur, vous pouvez ajouter et supprimer des chaînes de la base de données Redis. Le cache Redis est responsable du stockage des données d’application. Les données sont donc disponibles même après le redémarrage de l’application après la mise à l’échelle à zéro.

Vous pouvez également supprimer une liaison de votre application.
Dissociez le service de développement Redis.

Pour supprimer une liaison d’une application conteneur, utilisez l’option --unbind.
```
az containerapp update \
  --name myapp \
  --unbind myredis \
  --resource-group "$RESOURCE_GROUP"
```
L’application est conçue de sorte que les chaînes de texte sont stockées en mémoire si les variables d’environnement ne sont pas définies.

Dans cet état, les données sont perdues si l’application est mise à l’échelle à zéro.

Vous pouvez vérifier cette modification en retournant à votre navigateur web et en actualisant l’application web. Vous pouvez maintenant voir que les informations de configuration affichées indiquent que les données sont stockées en mémoire.

Vous pouvez maintenant lier à nouveau l’application au service Redis pour voir vos données précédemment stockées.
Liez à nouveau le service de développement Redis.
```
az containerapp update \
  --name myapp \
  --bind myredis \
  --resource-group "$RESOURCE_GROUP"
```
Une fois le service reconnecté, vous pouvez actualiser l’application web pour voir les données stockées dans Redis.

Connexion à un service géré

Une fois votre application prête à passer en production, vous pouvez lier votre application à un service géré au lieu d’un service de développement.

Les étapes suivantes lient votre application à une instance d’Azure Cache pour Redis existante.

Créez une variable pour votre nom DNS.

Veillez à remplacer <YOUR_DNS_NAME> par le nom DNS de votre instance d’Azure Cache pour Redis.
```
AZURE_REDIS_DNS_NAME=<YOUR_DNS_NAME>
```
Liez à Azure Cache pour Redis.
```
az containerapp update \
  --name myapp \
  --unbind myredis \
  --bind "$AZURE_REDIS_DNS_NAME" \
  --resource-group "$RESOURCE_GROUP"
```
Cette commande supprime simultanément la liaison de développement et établit la liaison au service géré au niveau de la production.
Revenez sur votre navigateur et actualisez la page.

La console affiche des valeurs comme dans l’exemple suivant.
```
AZURE_REDIS_DATABASE=0
AZURE_REDIS_HOST=azureRedis.redis.cache.windows.net
AZURE_REDIS_PASSWORD=il6HI...
AZURE_REDIS_PORT=6380
AZURE_REDIS_SSL=true
```
Remarque

Les noms de variables d’environnement utilisés pour les modules complémentaires et les services gérés varient légèrement.

Si vous souhaitez voir l’exemple de code utilisé pour ce tutoriel, consultez https://github.com/Azure-Samples/sample-service-redis.

À présent, lorsque vous ajoutez de nouvelles chaînes, les valeurs sont stockées dans une instance Azure Cache pour Redis au lieu du service de développement.

Nettoyer les ressources

Si vous ne prévoyez pas de continuer à utiliser les ressources créées dans ce tutoriel, vous pouvez supprimer l’application et le service Redis.

L’application et le service sont indépendants. Cette indépendance signifie que le service peut être connecté à n’importe quel nombre d’applications dans l’environnement et qu’il existe jusqu’à ce qu’il soit supprimé explicitement, même si toutes les applications en sont déconnectées.

Exécutez les commandes suivantes pour supprimer votre application conteneur et le service de développement.

az containerapp delete --name myapp
az containerapp add-on redis delete --name myredis

Vous pouvez également supprimer le groupe de ressources pour supprimer l’application conteneur et tous les services.

az group delete \
  --resource-group "$RESOURCE_GROUP"

Étapes suivantes

Gestion du cycle de vie des applications

Partager via