Snabbstart: Distribuera ett program med dapr-klustertillägget (förhandsversion) för Azure Kubernetes Service (AKS)

I den här snabbstarten lär du dig att använda Dapr-klustertillägget i ett AKS-kluster. Du kommer att distribuera ett Hello World-exempel som består av ett Python-program som genererar meddelanden och ett Node-program som använder och bevarar dem.

Förutsättningar

• En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto.
• Azure CLI installerat.
• Ett AKS-kluster med Dapr-klustertillägget aktiverat

Klona lagringsplatsen

För att hämta de filer som du kommer att använda för att distribuera exempelprogrammet klonar du lagringsplatsen Snabbstarter och ändrar till hello-kubernetes katalogen:

git clone https://github.com/dapr/quickstarts.git
cd quickstarts/hello-kubernetes

Skapa och konfigurera ett tillståndslager

Dapr kan använda ett antal olika tillståndslager (Redis, CosmosDB, DynamoDB, Cassandra osv.) för att bevara och hämta tillstånd. I det här exemplet använder vi Redis.

Skapa en Redis-butik

1. Öppna Azure Portal för att starta azure-Redis Cache skapa flödet.
2. Fyll i nödvändig information
3. Klicka på "Skapa" för att starta distributionen av Redis-instansen.
4. Anteckna värdnamnet för din Redis-instans, som du kan hämta från "Översikt" i Azure. Det bör se ut som xxxxxx.redis.cache.windows.net:6380 .
5. När instansen har skapats måste du hämta din åtkomstnyckel. Gå till "Åtkomstnycklar" under "Inställningar" och skapa en Kubernetes-hemlighet för att lagra ditt Redis-lösenord:

kubectl create secret generic redis --from-literal=redis-password=<your-redis-password>

Konfigurera Dapr-komponenterna

När din butik har skapats måste du lägga till nycklarna i filen redis.yaml i katalogen deploy för den Hello World lagringsplatsen. Ersätt värdet redisHost med din egen Redis-huvudadress och redisPassword med din egen hemlighet. Du kan läsa mer här.

Du måste också lägga till följande två rader nedan för redisPassword att aktivera anslutning via TLS:

- name: redisPassword
    secretKeyRef:
      name: redis
      key: redis-password
- name: enableTLS
  value: true

Tillämpa konfigurationen

Tillämpa redis.yaml filen:

kubectl apply -f ./deploy/redis.yaml

Kontrollera att tillståndslagret har konfigurerats i utdata:

component.dapr.io/statestore created

Distribuera Node.js med Dapr-sidovagnen

Använd Node.js-appens distribution till klustret:

kubectl apply -f ./deploy/node.yaml

kubectl rollout status deploy/nodeapp

Då distribueras Node.js till Kubernetes. Dapr-kontrollplanet matar automatiskt in Dapr-sidovagnen i podden. Om du tar en titt på node.yaml filen ser du hur Dapr är aktiverat för distributionen:

• dapr.io/enabled: true – detta talar om för Dapr-kontrollplanet att mata in en sidovagn till den här distributionen.

• dapr.io/app-id: nodeapp – Detta tilldelar ett unikt ID eller namn till Dapr-programmet, så att det kan skickas meddelanden till och kommuniceras med av andra Dapr-appar.

Du kommer åt din tjänst genom att hämta och anteckna EXTERNAL-IP via kubectl :

kubectl get svc nodeapp

Verifiera tjänsten

Anropa tjänsten genom att köra:

curl $EXTERNAL_IP/ports

Du bör se utdata som liknar följande:

{"DAPR_HTTP_PORT":"3500","DAPR_GRPC_PORT":"50001"}

Skicka sedan en order till programmet:

curl --request POST --data "@sample.json" --header Content-Type:application/json $EXTERNAL_IP/neworder

Bekräfta att ordern har bevarats genom att begära den:

curl $EXTERNAL_IP/order

Du bör se utdata som liknar följande:

{ "orderId": "42" }

kubectl port-forward svc/dapr-dashboard -n dapr-system 8080:8080

Distribuera Python-appen med Dapr-sidovagnen

Ta en snabb titt på Python-appen. Gå till Python-appkatalogen i hello-kubernetes snabbstarten och öppna app.py .

Det här är en grundläggande Python-app som publicerar JSON-meddelanden till localhost:3500 , vilket är standardporten för lyssning för Dapr. Du kan anropa Node.js-programmets neworder slutpunkt genom att publicera till v1.0/invoke/nodeapp/method/neworder . Meddelandet innehåller vissa data med en orderId som ökar en gång per sekund:

n = 0
while True:
    n += 1
    message = {"data": {"orderId": n}}

    try:
        response = requests.post(dapr_url, json=message)
    except Exception as e:
        print(e)

    time.sleep(1)

Distribuera Python-appen till ditt Kubernetes-kluster:

kubectl apply -f ./deploy/python.yaml

kubectl rollout status deploy/pythonapp

Observera meddelanden och bekräfta beständighet

Nu när både Node.js- och Python-programmen har distribuerats kan du titta på meddelanden.

Hämta loggarna för Node.js appen:

kubectl logs --selector=app=node -c node --tail=-1

Om distributionerna lyckades bör du se loggar som dessa:

Got a new order! Order ID: 1
Successfully persisted state
Got a new order! Order ID: 2
Successfully persisted state
Got a new order! Order ID: 3
Successfully persisted state

Anropa Node.js-appens orderslutpunkt för att hämta den senaste ordern. Hämta den externa IP-adress som du sparade tidigare och lägg till "/order" och utför en GET-begäran mot den (ange den i webbläsaren, använd Postman eller curl den!):

curl $EXTERNAL_IP/order
{"orderID":"42"}

Du bör se den senaste JSON-informationen i svaret.

Rensa resurser

Använd kommandot az group delete för att ta bort resursgruppen, AKS-klustret, namnområdet och alla relaterade resurser.

az group delete --name MyResourceGroup

Nästa steg

När du har distribuerat det här exempelprogrammet: