Esercitazione: Connessione a un servizio cache di Azure per Redis in App Azure Container (anteprima)

Articolo
10/18/2023

App Azure Container consente di connettersi ai servizi che supportano l'app eseguita nello stesso ambiente dell'app contenitore.

Durante lo sviluppo, l'applicazione può creare e connettersi rapidamente ai servizi di sviluppo. Questi servizi sono facili da creare e sono servizi di livello di sviluppo progettati per ambienti non di produzione.

Quando si passa all'ambiente di produzione, l'applicazione può connettere servizi gestiti di livello di produzione.

Questa esercitazione illustra come connettere sia il livello di sviluppo che quello di produzione cache di Azure per Redis servizio all'app contenitore.

Questa esercitazione apprendi come:

Creare un nuovo servizio di sviluppo Redis
Connessione un'app contenitore al servizio di sviluppo Redis
Disconnettere il servizio dall'applicazione
Esaminare il servizio che esegue una cache in memoria

Prerequisiti

Risorsa	Descrizione
Account di Azure	È necessaria una sottoscrizione attiva. Se non hai un account, puoi crearlo gratuitamente.
Interfaccia della riga di comando di Azure	Installare l'interfaccia della riga di comando di Azure se non è disponibile nel computer.
Gruppo di risorse di Azure	Creare un gruppo di risorse denominato my-services-resource-group nell'area Stati Uniti orientali.
Cache Redis di Azure	Creare un'istanza di cache di Azure per Redis nel gruppo my-services-resource-group.

Configurazione

Accedere all'interfaccia della riga di comando di Azure.
```
az login
```
Aggiornare l'estensione dell'interfaccia della riga di comando di App contenitore.
```
az extension add --name containerapp --upgrade
```

Registrare lo spazio dei nomi Microsoft.App.

az provider register --namespace Microsoft.App

Registrare lo spazio dei nomi Microsoft.ServiceLinker.

az provider register --namespace Microsoft.ServiceLinker

Configurare la variabile del gruppo di risorse.
```
RESOURCE_GROUP="my-services-resource-group"
```
Creare una variabile per il nome DNS cache di Azure per Redis.

Per visualizzare un elenco delle istanze di cache di Azure per Redis, eseguire il comando seguente.
```
az redis list --resource-group "$RESOURCE_GROUP" --query "[].name" -o table
```
Creare una variabile per contenere il nome dell'ambiente.

Sostituire <MY_ENVIRONMENT_NAME> con il nome dell'ambiente delle app contenitore.
```
ENVIRONMENT=<MY_ENVIRONMENT_NAME>
```
Configurare la variabile di posizione.
```
LOCATION="eastus"
```

Creare un nuovo ambiente.

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

Con l'interfaccia della riga di comando configurata e un ambiente creato, è ora possibile creare un'applicazione e un servizio di sviluppo.

Creare un servizio di sviluppo

L'applicazione di esempio gestisce un set di stringhe, in memoria o nella cache Redis.

Creare il servizio di sviluppo Redis e denominarlo myredis.

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

Creare un'app contenitore

Creare quindi l'app contenitore accessibile da Internet.

Creare una nuova app contenitore e associarla al servizio 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
```
Questo comando restituisce il nome di dominio completo (FQDN). Incollare questo percorso in un Web browser in modo da poter esaminare il comportamento dell'applicazione in questa esercitazione.

Il containerapp create comando usa l'opzione --bind per creare un collegamento tra l'app contenitore e il servizio di sviluppo Redis.

La richiesta di associazione raccoglie informazioni di connessione, incluse le credenziali e le stringa di connessione, e la inserisce nell'applicazione come variabili di ambiente. Questi valori sono ora disponibili per il codice dell'applicazione da usare per creare una connessione al servizio.

In questo caso, le variabili di ambiente seguenti sono disponibili per l'applicazione:
```
REDIS_ENDPOINT=myredis:6379
REDIS_HOST=myredis
REDIS_PASSWORD=...
REDIS_PORT=6379
```
Se si accede all'applicazione tramite un browser, è possibile aggiungere e rimuovere stringhe dal database Redis. La cache Redis è responsabile dell'archiviazione dei dati dell'applicazione, quindi i dati sono disponibili anche dopo il riavvio dell'applicazione dopo il ridimensionamento a zero.

È anche possibile rimuovere un'associazione dall'applicazione.
Annullare l'associazione del servizio di sviluppo Redis.

Per rimuovere un'associazione da un'app contenitore, usare l'opzione --unbind .
```
az containerapp update \
  --name myapp \
  --unbind myredis \
  --resource-group "$RESOURCE_GROUP"
```
L'applicazione viene scritta in modo che, se le variabili di ambiente non sono definite, le stringhe di testo vengono archiviate in memoria.

In questo stato, se l'applicazione viene ridimensionata su zero, i dati andranno persi.

È possibile verificare questa modifica restituendo al Web browser e aggiornando l'applicazione Web. È ora possibile visualizzare le informazioni di configurazione visualizzate indica che i dati sono archiviati in memoria.

È ora possibile riassociare l'applicazione al servizio Redis per visualizzare i dati archiviati in precedenza.
Riassociare il servizio di sviluppo Redis.
```
az containerapp update \
  --name myapp \
  --bind myredis \
  --resource-group "$RESOURCE_GROUP"
```
Con il servizio riconnesso, è possibile aggiornare l'applicazione Web per visualizzare i dati archiviati in Redis.

Connessione a un servizio gestito

Quando l'applicazione è pronta per passare all'ambiente di produzione, è possibile associare l'applicazione a un servizio gestito anziché a un servizio di sviluppo.

I passaggi seguenti associano l'applicazione a un'istanza esistente di cache di Azure per Redis.

Creare una variabile per il nome DNS.

Assicurarsi di sostituire <YOUR_DNS_NAME> con il nome DNS dell'istanza di cache di Azure per Redis.
```
AZURE_REDIS_DNS_NAME=<YOUR_DNS_NAME>
```
Eseguire l'associazione a cache di Azure per Redis.
```
az containerapp update \
  --name myapp \
  --unbind myredis \
  --bind "$AZURE_REDIS_DNS_NAME" \
  --resource-group "$RESOURCE_GROUP"
```
Questo comando rimuove contemporaneamente l'associazione di sviluppo e stabilisce l'associazione al servizio gestito di livello di produzione.
Tornare nel browser e aggiornare la pagina.

La console stampa i valori come nell'esempio seguente.
```
AZURE_REDIS_DATABASE=0
AZURE_REDIS_HOST=azureRedis.redis.cache.windows.net
AZURE_REDIS_PASSWORD=il6HI...
AZURE_REDIS_PORT=6380
AZURE_REDIS_SSL=true
```
Nota

I nomi delle variabili di ambiente usati per i componenti aggiuntivi e i servizi gestiti variano leggermente.

Per visualizzare il codice di esempio usato per questa esercitazione, vedere https://github.com/Azure-Samples/sample-service-redis.

Quando si aggiungono nuove stringhe, i valori vengono archiviati in un'istanza cache di Azure per Redis anziché nel servizio di sviluppo.

Pulire le risorse

Se non si prevede di continuare a usare le risorse create in questa esercitazione, è possibile eliminare l'applicazione e il servizio Redis.

L'applicazione e il servizio sono indipendenti. Questa indipendenza significa che il servizio può essere connesso a un numero qualsiasi di applicazioni nell'ambiente ed esiste fino a quando non viene eliminato in modo esplicito, anche se tutte le applicazioni si disconnettono da esso.

Eseguire i comandi seguenti per eliminare l'app contenitore e il servizio di sviluppo.

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

In alternativa, è possibile eliminare il gruppo di risorse per rimuovere l'app contenitore e tutti i servizi.

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

Passaggi successivi

Gestione del ciclo di vita delle applicazioni

Share via