Zelfstudie: Verbinding maken naar een Azure Cache voor Redis-service in Azure Container Apps (preview)

Artikel
10/18/2023

Met Azure Container Apps kunt u verbinding maken met services die ondersteuning bieden voor uw app die worden uitgevoerd in dezelfde omgeving als uw container-app.

Wanneer u in ontwikkeling bent, kan uw toepassing snel dev-services maken en er verbinding mee maken. Deze services zijn eenvoudig te maken en zijn hoogwaardige services die zijn ontworpen voor niet-productieomgevingen.

Wanneer u overstapt naar productie, kan uw toepassing beheerde services op productieniveau verbinden.

In deze zelfstudie leert u hoe u zowel ontwikkel- als productiekwaliteit Azure Cache voor Redis service verbindt met uw container-app.

In deze zelfstudie leert u het volgende:

Een nieuwe Redis-ontwikkelservice maken
een container-app Verbinding maken naar de Redis-ontwikkelservice
De service loskoppelen van de toepassing
De service controleren waarop een cache in het geheugen wordt uitgevoerd

Vereisten

Bron	Beschrijving
Azure-account	Er is een actief abonnement vereist. Als u geen account hebt, kunt u er gratis een maken.
Azure-CLI	Installeer de Azure CLI als u deze niet op uw computer hebt.
Azure-resourcegroep	Maak een resourcegroep met de naam my-services-resource-group in de regio VS - oost.
Azure Cache voor Redis	Maak een exemplaar van Azure Cache voor Redis in de resourcegroep my-services.

Instellingen

Meld u aan bij de Azure CLI.
```
az login
```
Voer een upgrade uit van de CLI-extensie voor Container Apps.
```
az extension add --name containerapp --upgrade
```

Registreer de Microsoft.App naamruimte.

az provider register --namespace Microsoft.App

Registreer de Microsoft.ServiceLinker naamruimte.

az provider register --namespace Microsoft.ServiceLinker

Stel de resourcegroepvariabele in.

RESOURCE_GROUP="my-services-resource-group"

Maak een variabele voor de Azure Cache voor Redis DNS-naam.

Voer de volgende opdracht uit om een lijst met de Azure Cache voor Redis exemplaren weer te geven.
```
az redis list --resource-group "$RESOURCE_GROUP" --query "[].name" -o table
```
Maak een variabele om uw omgevingsnaam op te slaan.

Vervang door <MY_ENVIRONMENT_NAME> de naam van uw container-apps-omgeving.
```
ENVIRONMENT=<MY_ENVIRONMENT_NAME>
```
Stel de locatievariabele in.
```
LOCATION="eastus"
```

Maak een nieuwe omgeving.

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

Nu de CLI is geconfigureerd en een omgeving is gemaakt, kunt u nu een toepassing en dev-service maken.

Een dev-service maken

De voorbeeldtoepassing beheert een reeks tekenreeksen, in het geheugen of in redis-cache.

Maak de Redis dev-service en geef deze myrediseen naam.

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

Een container-app maken

Maak vervolgens uw container-app die toegankelijk is voor internet.

Maak een nieuwe container-app en bind deze aan de Redis-service.
```
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
```
Met deze opdracht wordt de FQDN (Fully Qualified Domain Name) geretourneerd. Plak deze locatie in een webbrowser, zodat u het gedrag van de toepassing in deze zelfstudie kunt inspecteren.

De containerapp create opdracht gebruikt de --bind optie om een koppeling te maken tussen de container-app en de Redis-ontwikkelservice.

De bindingsaanvraag verzamelt verbindingsgegevens, inclusief referenties en verbindingsreeks s, en injecteert deze in de toepassing als omgevingsvariabelen. Deze waarden zijn nu beschikbaar voor de toepassingscode die moet worden gebruikt om een verbinding met de service te maken.

In dit geval zijn de volgende omgevingsvariabelen beschikbaar voor de toepassing:
```
REDIS_ENDPOINT=myredis:6379
REDIS_HOST=myredis
REDIS_PASSWORD=...
REDIS_PORT=6379
```
Als u de toepassing opent via een browser, kunt u tekenreeksen toevoegen aan en verwijderen uit de Redis-database. De Redis-cache is verantwoordelijk voor het opslaan van toepassingsgegevens, zodat gegevens beschikbaar zijn, zelfs nadat de toepassing opnieuw is opgestart na het schalen naar nul.

U kunt ook een binding uit uw toepassing verwijderen.
De Redis-ontwikkelservice ontkoppelen.

Als u een binding uit een container-app wilt verwijderen, gebruikt u de --unbind optie.
```
az containerapp update \
  --name myapp \
  --unbind myredis \
  --resource-group "$RESOURCE_GROUP"
```
De toepassing wordt geschreven zodat als de omgevingsvariabelen niet zijn gedefinieerd, de tekenreeksen in het geheugen worden opgeslagen.

Als de toepassing in deze status naar nul wordt geschaald, gaan gegevens verloren.

U kunt deze wijziging controleren door terug te keren naar uw webbrowser en de webtoepassing te vernieuwen. U kunt nu zien dat de weergegeven configuratie-informatie aangeeft dat gegevens in het geheugen zijn opgeslagen.

U kunt de toepassing nu opnieuw koppelen aan de Redis-service om uw eerder opgeslagen gegevens te bekijken.
De Redis-ontwikkelservice opnieuw verbinden.
```
az containerapp update \
  --name myapp \
  --bind myredis \
  --resource-group "$RESOURCE_GROUP"
```
Wanneer de service opnieuw is verbonden, kunt u de webtoepassing vernieuwen om gegevens te zien die zijn opgeslagen in Redis.

Verbinding maken naar een beheerde service

Wanneer uw toepassing klaar is om naar productie te gaan, kunt u uw toepassing verbinden met een beheerde service in plaats van een dev-service.

De volgende stappen binden uw toepassing aan een bestaand exemplaar van Azure Cache voor Redis.

Maak een variabele voor uw DNS-naam.

Zorg ervoor dat u vervangt door <YOUR_DNS_NAME> de DNS-naam van uw exemplaar van Azure Cache voor Redis.
```
AZURE_REDIS_DNS_NAME=<YOUR_DNS_NAME>
```
Binden aan Azure Cache voor Redis.
```
az containerapp update \
  --name myapp \
  --unbind myredis \
  --bind "$AZURE_REDIS_DNS_NAME" \
  --resource-group "$RESOURCE_GROUP"
```
Met deze opdracht wordt tegelijkertijd de ontwikkelingsbinding verwijderd en wordt de binding met de beheerde service op productieniveau tot stand gebracht.
Ga terug naar uw browser en vernieuw de pagina.

In de console worden waarden afgedrukt zoals in het volgende voorbeeld.
```
AZURE_REDIS_DATABASE=0
AZURE_REDIS_HOST=azureRedis.redis.cache.windows.net
AZURE_REDIS_PASSWORD=il6HI...
AZURE_REDIS_PORT=6380
AZURE_REDIS_SSL=true
```
Notitie

Namen van omgevingsvariabelen die worden gebruikt voor invoegtoepassingen en beheerde services variëren enigszins.

Als u de voorbeeldcode wilt zien die voor deze zelfstudie wordt gebruikt, raadpleegt https://github.com/Azure-Samples/sample-service-redisu .

Wanneer u nu nieuwe tekenreeksen toevoegt, worden de waarden opgeslagen in een exemplaar Azure Cache voor Redis in plaats van de dev-service.

Resources opschonen

Als u niet van plan bent om de resources te blijven gebruiken die in deze zelfstudie zijn gemaakt, kunt u de toepassing en de Redis-service verwijderen.

De toepassing en de service zijn onafhankelijk. Deze onafhankelijkheid betekent dat de service kan worden verbonden met een willekeurig aantal toepassingen in de omgeving en bestaat totdat deze expliciet wordt verwijderd, zelfs als alle toepassingen er geen verbinding mee hebben.

Voer de volgende opdrachten uit om uw container-app en de dev-service te verwijderen.

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

U kunt ook de resourcegroep verwijderen om de container-app en alle services te verwijderen.

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

Volgende stappen

Beheer van de levenscyclus van toepassingen

Share via