Guida introduttiva: Eseguire l'integrazione con Database di Azure per PostgreSQL e cache di Azure per Redis

Nota

Azure Spring Apps è il nuovo nome del servizio Azure Spring Cloud. Anche se il servizio ha un nuovo nome, il nome precedente verrà visualizzato in alcune posizioni per un po' mentre si lavora per aggiornare gli asset, ad esempio screenshot, video e diagrammi.

Questo articolo si applica a:❌ Basic/Standard ✔️ Enterprise

Questa guida introduttiva illustra come effettuare il provisioning e preparare un Database di Azure per PostgreSQL e un cache di Azure per Redis da usare con le app in esecuzione nel piano Enterprise di Azure Spring Apps.

Questo articolo usa questi servizi a scopo dimostrativo. È possibile connettere l'applicazione a qualsiasi servizio di backup preferito usando istruzioni simili a quelle della sezione Create Service Connessione ors più avanti in questo articolo.

Prerequisiti

• Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
• Comprendere e soddisfare la sezione Requisiti del piano Enterprise in Azure Marketplace.
• Interfaccia della riga di comando di Azure versione 2.45.0 o successiva.
• Git.
• jq
• Estensione del piano Enterprise di Azure Spring Apps. Usare il comando seguente per rimuovere le versioni precedenti e installare l'estensione del piano Enterprise più recente. Se l'estensione spring-cloud è stata installata in precedenza, disinstallarla per evitare la mancata corrispondenza della configurazione e della versione.

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

• Completare i passaggi descritti in Compilare e distribuire app in Azure Spring Apps usando il piano Enterprise.

Effettuare il provisioning dei servizi

Per aggiungere la persistenza all'applicazione, creare un cache di Azure per Redis e un server flessibile Database di Azure per PostgreSQL.

Interfaccia della riga di comando di Azure

I passaggi seguenti descrivono come effettuare il provisioning di un'istanza di cache di Azure per Redis e di un server flessibile Database di Azure per PostgreSQL usando l'interfaccia della riga di comando di Azure.

1. Creare variabili per contenere i nomi delle risorse usando i comandi seguenti. Assicurarsi di sostituire i segnaposto con i propri valori.

   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. Usare il comando seguente per creare un'istanza di cache di Azure per Redis:

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

   Nota

   La creazione della cache Redis richiede circa 20 minuti.

3. Usare il comando seguente per creare un'istanza del server flessibile Database di Azure per 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. Usare il comando seguente per consentire le connessioni da altri servizi di Azure al server flessibile appena creato:

   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. Usare il comando seguente per abilitare l'estensione uuid-ossp per il server flessibile appena creato:

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

6. Usare il comando seguente per creare un database per l'applicazione Order Service:

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

7. Usare il comando seguente per creare un database per l'applicazione del servizio catalogo:

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

Modello ARM

Le istruzioni seguenti descrivono come effettuare il provisioning di un cache di Azure per Redis e di un server flessibile Database di Azure per PostgreSQL usando un modello di Azure Resource Manager (modello di Resource Manager).

Un modello di Azure Resource Manager è un file JSON (JavaScript Object Notation) che definisce l'infrastruttura e la configurazione per il progetto. Il modello utilizza la sintassi dichiarativa. Si descrive la distribuzione prevista senza scrivere la sequenza di comandi di programmazione per creare la distribuzione.

Il modello usato in questa guida introduttiva è disponibile nel repository GitHub di esempio dell'archivio fitness.

Per distribuire questo modello, seguire questa procedura:

1. Selezionare l'immagine seguente per accedere ad Azure e aprire un modello. Il modello crea un cache di Azure per Redis e un server flessibile Database di Azure per PostgreSQL.

   

2. Specifica i valori per i seguenti campi:

   • Gruppo di risorse: selezionare Crea nuovo, immettere un nome univoco per il gruppo di risorse e quindi selezionare OK.
   • cacheName: immettere il nome del server cache di Azure per Redis.
   • dbServerName: immettere il nome del server flessibile Database di Azure per PostgreSQL.
   • administratorLogin: immettere il nome utente amministratore per il server flessibile Database di Azure per PostgreSQL.
   • administratorLoginPassword: immettere la password amministratore per il server flessibile Database di Azure per PostgreSQL.
   • tags: immettere eventuali tag personalizzati.

3. Selezionare Rivedi e crea e quindi Crea.

Creare Connessione or di servizio

I passaggi seguenti illustrano come associare le applicazioni in esecuzione nel piano Enterprise di Azure Spring Apps ad altri servizi di Azure usando i Connessione or di servizio.

1. Usare il comando seguente per creare un connettore di servizio per Database di Azure per PostgreSQL per l'applicazione 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. Usare il comando seguente per creare un connettore di servizio per Database di Azure per PostgreSQL per l'applicazione del servizio catalogo:

   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. Usare il comando seguente per creare un connettore di servizio per cache di Azure per Redis per l'applicazione del servizio carrello:

   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. Usare il comando seguente per ricaricare l'applicazione del servizio catalogo per caricare le nuove proprietà di connessione:

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

5. Usare il comando seguente per recuperare le informazioni di connessione al database:

   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)
   

   Nota

   Se si ottiene un'eccezione di verifica SSL con Nofsql 6.0, assicurarsi di modificare la modalità SSL da Require a VerifyFull. Per altre informazioni, vedere le note sulla versione di Npgsql 6.0.

6. Usare il comando seguente per aggiornare l'applicazione 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. Usare i comandi seguenti per recuperare le informazioni di connessione di Redis e aggiornare l'applicazione servizio carrello:

   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}"
   

Accedere all'applicazione

Recuperare l'URL per Spring Cloud Gateway ed esplorare l'applicazione aggiornata. È possibile usare l'output del comando seguente per esplorare l'applicazione:

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}"

Pulire le risorse

Se si prevede di usare le guide di avvio rapido e le esercitazioni successive, è consigliabile non cancellare le risorse create. Quando non è più necessario, eliminare il gruppo di risorse per eliminare tutte le risorse contenute al suo interno. Per eliminare il gruppo di risorse usando l'interfaccia della riga di comando di Azure, usare i comandi seguenti:

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

Passaggi successivi

Continuare con uno degli argomenti di avvio rapido facoltativi seguenti:

• Configurare Single Sign-On
• Caricare i segreti dell'applicazione con Key Vault
• Monitorare le applicazioni end-to-end
• Impostare i limiti di frequenza delle richieste
• Automatizzare le distribuzioni
• Integrare Azure OpenAI