Démarrage rapide : Intégrer à Azure Database pour PostgreSQL et Azure Cache pour Redis

Notes

Azure Spring Apps est le nouveau nom du service Azure Spring Cloud. Bien que le service ait un nouveau nom, vous verrez l’ancien nom à divers endroits pendant un certain temps, car nous travaillons à mettre à jour les ressources telles que les captures d’écran, les vidéos et les diagrammes.

Cet article s’applique à :❌ De base/Standard ✔️ Enterprise

Ce démarrage rapide montre comment approvisionner et préparer Azure Database pour PostgreSQL et Azure Cache pour Redis en vue d’une utilisation avec des applications s’exécutant dans le plan Enterprise d’Azure Spring Apps.

Cet article utilise ces services à des fins de démonstration. Vous pouvez connecter votre application à n’importe quel service de soutien de votre choix en suivant des instructions similaires à celles de la section Créer des connecteurs de service plus loin dans cet article.

Prérequis

• Compte Azure avec un abonnement actif. Créez un compte gratuitement.
• Comprendre la section Exigences du plan niveau Enterprise dans la place de marché Azure et y répondre.
• Azure CLI version 2.45.0 ou ultérieure.
• Git.
• jq
• L’extension de plan Enterprise d’Azure Spring Apps. Utilisez la commande suivante pour supprimer les versions précédentes et installer l’extension de plan Enterprise la plus récente. Si vous avez déjà installé l’extension spring-cloud, désinstallez-la pour éviter les incompatibilités de configuration et de version.

  az extension add --upgrade --name spring
  az extension remove --name spring-cloud
  

• Effectuez les étapes indiquées dans Créer et déployer des applications sur Azure Spring Apps à l’aide du plan Enterprise.

Configurer des services

Pour ajouter la persistance à l’application, créez un Azure Cache pour Redis et un serveur flexible Azure Database pour PostgreSQL.

Azure CLI

Les étapes suivantes décrivent comment provisionner une instance d’Azure Cache pour Redis et un serveur flexible Azure Database pour PostgreSQL à l’aide d’Azure CLI.

1. Créez des variables destinées à contenir les noms de ressources à l’aide des commandes suivantes. Veillez à remplacer les espaces réservés par vos valeurs.

   export REGION=<region>
   export RESOURCE_GROUP=<resource-group-name>
   export REDIS_CACHE_NAME=<redis-cache-name>
   export POSTGRES_SERVER_NAME=<postgres-server-name>
   export POSTGRES_USERNAME=<postgres-username>
   export POSTGRES_PASSWORD=<postgres-password>
   export AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME=<Azure-Spring-Apps-service-instance-name>
   

2. Utilisez la commande suivante pour créer une instance d’Azure Cache pour Redis :

   az redis create \
       --resource-group ${RESOURCE_GROUP} \
       --name ${REDIS_CACHE_NAME} \
       --location ${REGION} \
       --sku Basic \
       --vm-size c0
   

   Notes

   La création du Cache Redis prend environ 20 minutes.

3. Utilisez la commande suivante pour créer une instance de serveur flexible Azure Database pour PostgreSQL :

   az postgres flexible-server create \
       --resource-group ${RESOURCE_GROUP} \
       --name ${POSTGRES_SERVER_NAME} \
       --location ${REGION} \
       --admin-user ${POSTGRES_USERNAME} \
       --admin-password ${POSTGRES_PASSWORD} \
       --yes
   

4. Utilisez la commande suivante pour autoriser les connexions d’autres services Azure au nouveau serveur flexible :

   az postgres flexible-server firewall-rule create \
       --rule-name allAzureIPs \
       --name ${POSTGRES_SERVER_NAME} \
       --resource-group ${RESOURCE_GROUP} \
       --start-ip-address 0.0.0.0 \
       --end-ip-address 0.0.0.0
   

5. Utilisez la commande suivante pour activer l’extension uuid-ossp pour le nouveau serveur flexible :

   az postgres flexible-server parameter set \
       --resource-group ${RESOURCE_GROUP} \
       --name azure.extensions \
       --value uuid-ossp \
       --server-name ${POSTGRES_SERVER_NAME}
   

6. Utilisez la commande suivante pour créer une base de données pour l’application Order Service :

   az postgres flexible-server db create \
       --resource-group ${RESOURCE_GROUP} \
       --server-name ${POSTGRES_SERVER_NAME} \
       --database-name acmefit_order
   

7. Utilisez la commande suivante pour créer une base de données pour l’application Catalog Service :

   az postgres flexible-server db create \
       --resource-group ${RESOURCE_GROUP} \
       --server-name ${POSTGRES_SERVER_NAME} \
       --database-name acmefit_catalog
   

Modèle ARM

Les instructions suivantes décrivent comment provisionner un Azure Cache pour Redis et un serveur flexible Azure Database pour PostgreSQL à l’aide d’un modèle Azure Resource Manager (modèle ARM).

Un modèle Azure Resource Manager est un fichier JSON (JavaScript Object Notation) qui définit l’infrastructure et la configuration de votre projet. Le modèle utilise la syntaxe déclarative. Vous décrivez le déploiement que vous avez prévu sans écrire la séquence de commandes de programmation pour créer le déploiement.

Vous trouverez le modèle utilisé dans ce guide de démarrage rapide dans le dépôt GitHub de l’exemple de magasin de remise en forme.

Suivez ces étapes pour déployer ce modèle :

1. Cliquez sur l’image ci-après pour vous connecter à Azure et ouvrir un modèle. Le modèle crée un Azure Cache pour Redis et un serveur flexible Azure Database pour PostgreSQL.

   

2. Entrez des valeurs dans les champs suivants :

   • Groupe de ressources : sélectionnez Créer, entrez un nom unique pour le groupe de ressources, puis sélectionnez OK.
   • cacheName : entrez le nom du serveur Azure Cache pour Redis.
   • dbServerName : entrez le nom du serveur flexible Azure Database pour PostgreSQL.
   • administratorLogin : entrez le nom d’utilisateur administrateur du serveur flexible Azure Database pour PostgreSQL.
   • administratorLoginPassword : entrez le mot de passe administrateur du serveur flexible Azure Database pour PostgreSQL.
   • balises : entrez des balises personnalisées.

3. Sélectionnez Vérifier + créer, puis Créer.

Créer des connecteurs de service

Les étapes suivantes montrent comment lier des applications s’exécutant dans le plan Enterprise d’Azure Spring Apps à d’autres services Azure à l’aide de connecteurs de service.

1. Utilisez la commande suivante pour créer un connecteur de service pour Azure Database pour PostgreSQL pour l’application Order Service :

   az spring connection create postgres-flexible \
       --resource-group ${RESOURCE_GROUP} \
       --target-resource-group ${RESOURCE_GROUP} \
       --connection order_service_db \
       --service ${AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME} \
       --app order-service \
       --deployment default \
       --server ${POSTGRES_SERVER_NAME} \
       --database acmefit_order \
       --secret name=${POSTGRES_USERNAME} secret=${POSTGRES_PASSWORD} \
       --client-type dotnet
   

2. Utilisez la commande suivante pour créer un connecteur de service pour Azure Database pour PostgreSQL pour l’application Catalog Service :

   az spring connection create postgres-flexible \
       --resource-group ${RESOURCE_GROUP} \
       --target-resource-group ${RESOURCE_GROUP} \
       --connection catalog_service_db \
       --service ${AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME} \
       --app catalog-service \
       --deployment default \
       --server ${POSTGRES_SERVER_NAME} \
       --database acmefit_catalog \
       --secret name=${POSTGRES_USERNAME} secret=${POSTGRES_PASSWORD} \
       --client-type springboot
   

3. Utilisez la commande suivante pour créer un connecteur de service pour Azure Cache pour Redis pour l’application Cart Service :

   az spring connection create redis \
       --resource-group ${RESOURCE_GROUP} \
       --target-resource-group ${RESOURCE_GROUP} \
       --connection cart_service_cache \
       --service ${AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME} \
       --app cart-service \
       --deployment default \
       --server ${REDIS_CACHE_NAME} \
       --database 0 \
       --client-type java
   

4. Utilisez la commande suivante pour recharger l’application Catalog Service afin de charger les nouvelles propriétés de connexion :

   az spring app restart \
       --resource-group ${RESOURCE_GROUP} \
       --name catalog-service \
       --service ${AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME}
   

5. Utilisez la commande suivante pour récupérer les informations de connexion de base de données :

   export POSTGRES_CONNECTION_STR=$(az spring connection show \
       --resource-group ${RESOURCE_GROUP} \
       --service ${AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME} \
       --deployment default \
       --connection order_service_db \
       --app order-service \
       | jq '.configurations[0].value' -r)
   

   Notes

   Si vous obtenez une exception de vérification SSL avec Nofsql 6.0, assurez-vous de remplacer le mode SSL Require par VerifyFull. Pour plus d’informations, consultez les notes de publication sur Npgsql 6.0.

6. Utilisez la commande suivante pour mettre à jour l’application Order Service :

   az spring app update \
       --resource-group ${RESOURCE_GROUP} \
       --name order-service \
       --service ${AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME} \
       --env "DatabaseProvider=Postgres" "ConnectionStrings__OrderContext=${POSTGRES_CONNECTION_STR}"
   

7. Utilisez les commandes suivantes pour récupérer les informations de connexion Redis et mettre à jour l’application Cart Service :

   export REDIS_CONN_STR=$(az spring connection show \
       --resource-group ${RESOURCE_GROUP} \
       --service ${AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME} \
       --deployment default \
       --app cart-service \
       --connection cart_service_cache | jq -r '.configurations[0].value')
   
   export GATEWAY_URL=$(az spring gateway show \
       --resource-group ${RESOURCE_GROUP} \
       --service ${AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME} | jq -r '.properties.url')
   
   az spring app update \
       --resource-group ${RESOURCE_GROUP} \
       --name cart-service \
       --service ${AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME} \
       --env "CART_PORT=8080" "REDIS_CONNECTIONSTRING=${REDIS_CONN_STR}" "AUTH_URL=https://${GATEWAY_URL}"
   

Accéder à l’application

Récupérez l’URL de Spring Cloud Gateway et explorez l’application mise à jour. Vous pouvez utiliser la sortie de la commande suivante pour explorer l’application :

export GATEWAY_URL=$(az spring gateway show \
    --resource-group ${RESOURCE_GROUP} \
    --service ${AZURE_SPRING_APPS_SERVICE_INSTANCE_NAME} | jq -r '.properties.url')

echo "https://${GATEWAY_URL}"

Nettoyer les ressources

Si vous prévoyez d’utiliser d’autres guides de démarrage rapide et tutoriels, vous pouvez conserver ces ressources. Quand vous n’en avez plus besoin, supprimez le groupe de ressources, ce qui supprime également les ressources qu’il contient. Pour supprimer le groupe de ressources à l’aide d’Azure CLI, utilisez les commandes suivantes :

echo "Enter the Resource Group name:" &&
read resourceGroupName &&
az group delete --name $resourceGroupName &&
echo "Press [ENTER] to continue ..."

Étapes suivantes

Passez à l’un des guides de démarrage rapide facultatifs suivants :

• Configurer l’authentification unique
• Charger des secrets d’application avec Key Vault
• Monitorer des applications de bout en bout
• Définir des limites de taux de demandes
• Automatiser les déploiements
• Intégrer Azure OpenAI