Schnellstart: Bereitstellen einer Anwendung mithilfe der Dapr-Clustererweiterung für Azure Kubernetes Service (AKS) oder Arc-fähige Kubernetes-Instanzen

Artikel
01/10/2024

In dieser Schnellstartanleitung verwenden Sie die Dapr-Clustererweiterung in einem AKS- oder Kubernetes-Cluster mit Arc-Unterstützung. Sie stellen ein hello world-Beispiel bereit, das aus einer Python-Anwendung, die Nachrichten generiert, und einer Node-Anwendung besteht, die diese Nachrichten nutzt und dauerhaft speichert.

Voraussetzungen

Ein Azure-Abonnement. Falls Sie über kein Azure-Abonnement verfügen, können Sie ein kostenloses Konto erstellen.
Die Azure CLI oder Azure PowerShell muss installiert sein.
Ein AKS- oder Arc-fähiger Kubernetes-Cluster mit aktivierter Dapr-Clustererweiterung.

Klonen des Repositorys

Klonen Sie das Dapr-Schnellstartrepository mit dem Befehl git clone.
```
git clone https://github.com/dapr/quickstarts.git
```
Wechseln Sie mithilfe von cd in das Verzeichnis hello-kubernetes.
```
cd quickstarts/tutorials/hello-kubernetes/
```

Erstellen und Konfigurieren eines Zustandsspeichers

Dapr kann viele verschiedene Zustandsspeicher wie Redis, Azure Cosmos DB, DynamoDB und Cassandra verwenden, um den Zustand dauerhaft zu speichern und abzurufen. In diesem Beispiel verwenden wir die Redis.

Erstellen eines Redis-Speichers

Öffnen Sie das Azure-Portal, um den Erstellungsflow für Azure Cache for Redis zu starten.
Geben Sie die erforderlichen Informationen ein.
Wählen Sie Erstellen aus, um die Bereitstellung der Redis-Instanz zu starten.
Notieren Sie sich den Hostnamen Ihrer Redis-Instanz. Diesen können Sie in Azure im Abschnitt Übersicht abrufen. Der Hostname ist u. U. ähnlich wie im folgenden Beispiel: xxxxxx.redis.cache.windows.net:6380.
Navigieren Sie unter Einstellungen zu Zugriffsschlüssel, um Ihre Zugriffsschlüssel abzurufen.
Erstellen Sie mithilfe des Befehls kubectl create secret generic redis ein Kubernetes-Geheimnis, um Ihr Redis-Kennwort zu speichern.
```
kubectl create secret generic redis --from-literal=redis-password=<your-redis-password>
```

Konfigurieren der Dapr-Komponenten

Nachdem Ihr Speicher erstellt wurde, müssen Sie die Schlüssel der Datei redis.yaml im Bereitstellungsverzeichnis des Hallo Welt-Repositorys hinzufügen. Weitere Informationen erhalten Sie hier.

Ersetzen Sie den Wert redisHost durch Ihre eigene Redis-Masteradresse
und den Wert redisPassword durch Ihr eigenes Geheimnis.

Fügen Sie die folgenden beiden Zeilen unterhalb von redisPassword hinzu, um die Verbindung über TLS zu aktivieren:

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

Anwenden der Konfiguration

Wenden Sie die Datei redis.yaml mithilfe des Befehls kubectl apply an.
```
kubectl apply -f ./deploy/redis.yaml
```
Vergewissern Sie sich mithilfe des Befehls kubectl get components.redis, dass Ihr Zustandsspeicher erfolgreich konfiguriert wurde.
```
kubectl get components.redis -o yaml
```
Die Ausgabe sollte in etwa wie in folgender Beispielausgabe aussehen:
```
component.dapr.io/statestore created
```

Bereitstellen der Node.js-App mit dem Dapr-Sidecar

Wenden Sie die Bereitstellung der Node.js-App mit dem Befehl kubectl apply auf Ihren Cluster an.
```
kubectl apply -f ./deploy/node.yaml
```
Hinweis

Kubernetes-Bereitstellungen sind asynchron. Das bedeutet, dass Sie warten müssen, bis die Bereitstellung abgeschlossen ist, bevor Sie mit den nächsten Schritten fortfahren. Dazu können Sie den folgenden Befehl verwenden:
```
kubectl rollout status deploy/nodeapp
```
Dadurch wird die Node.js-App in Kubernetes bereitgestellt. Die Dapr-Steuerungsebene fügt den Dapr-Sidecar automatisch in den Pod ein. In der Datei node.yaml sehen Sie, wie Dapr für diese Bereitstellung aktiviert wird:
- dapr.io/enabled: true: Weist die Dapr-Steuerungsebene an, einen Sidecar in diese Bereitstellung einzufügen.
- dapr.io/app-id: nodeapp: Weist der Dapr-Anwendung eine eindeutige ID oder einen eindeutigen Namen zu, damit sie von anderen Dapr-Anwendungen Nachrichten empfangen und mit ihnen kommunizieren kann.
Greifen Sie mit dem Befehl kubectl get svc auf Ihren Dienst zu.
```
kubectl get svc nodeapp
```
Notieren Sie sich die EXTERNAL-IP aus der Ausgabe.

Überprüfen des Diensts

Rufen Sie den Dienst auf, indem Sie curl Ihrer EXTERNAL-IP verwenden.
```
curl $EXTERNAL_IP/ports
```
Die Ausgabe sollte in etwa wie in folgender Beispielausgabe aussehen:
```
{"DAPR_HTTP_PORT":"3500","DAPR_GRPC_PORT":"50001"}
```

Übermitteln Sie mit curl einen Auftrag an die Anwendung.

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

Vergewissern Sie sich, dass der Auftrag dauerhaft gespeichert wurde, indem Sie ihn mit curl anfordern.
```
curl $EXTERNAL_IP/order
```
Die Ausgabe sollte in etwa wie in folgender Beispielausgabe aussehen:
```
{ "orderId": "42" }
```

Bereitstellen der Python-App mit dem Dapr-Sidecar

Navigieren Sie in der Schnellstartanleitung hello-kubernetes zum Python-App-Verzeichnis, und öffnen Sie app.py.

Dieses Beispiel ist eine einfache Python-App, die JSON-Nachrichten an localhost:3500 sendet. Dabei handelt es sich um den standardmäßigen Lauschport für Dapr. Sie können den Endpunkt neworder der Node.js-Anwendung durch Posten in v1.0/invoke/nodeapp/method/neworder aufrufen. Die Nachricht enthält einige Daten mit einer Auftrags-ID (orderId), die sich einmal pro Sekunde erhöht:
```
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)
```
Stellen Sie die Python-App mit dem Befehl kubectl apply in Ihrem Kubernetes-Cluster bereit.
```
kubectl apply -f ./deploy/python.yaml
```
Hinweis

Wie beim vorherigen Befehl müssen Sie warten, bis die Bereitstellung abgeschlossen ist, bevor Sie mit den nächsten Schritten fortfahren. Dazu können Sie den folgenden Befehl verwenden:
```
kubectl rollout status deploy/pythonapp
```

Beobachten von Nachrichten und Bestätigen der Persistenz

Nachdem nun sowohl die Node.js- als auch die Python-Anwendung bereitgestellt wurden, sehen Sie, wie Nachrichten eingehen.

Rufen Sie die Protokolle der Node.js-App mithilfe des Befehls kubectl logs ab.

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

Wenn die Bereitstellungen erfolgreich waren, sollten Protokolle wie die folgenden Beispielprotokolle angezeigt werden:

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

Rufen Sie den Auftragsendpunkt der Node.js-App mit curl auf, um den neuesten Auftrag zu erhalten.
```
curl $EXTERNAL_IP/order
{"orderID":"42"}
```
In der Antwort sollte der neueste JSON-Code angezeigt werden.

Entfernen Sie die Ressourcengruppe, den Cluster, den Namespace und alle zugehörigen Ressourcen mithilfe des Befehls az group delete.
```
az group delete --name MyResourceGroup
```

Nächste Schritte

Weitere Informationen zu anderen Clustererweiterungen