Démarrage rapide : Déployer une application avec l’extension de cluster Dapr pour Azure Kubernetes Service (AKS) ou Kubernetes activé pour Arc

Article
01/10/2024

Dans ce guide de démarrage rapide, utilisez l’extension de cluster Dapr dans un cluster AKS ou Kubernetes activé pour Arc. Vous déployez un exemple hello world, constitué d’une application Python qui génère des messages et d’une application nœud qui les consomme et les conserve.

Prérequis

Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, vous pouvez créer un compte gratuit.
Azure CLI ou Azure PowerShell installé.
Un cluster Kubernetes AKS ou activé pour Arc avec l’extension de cluster Dapr activée.

Cloner le référentiel

Clonez le Référentiel de démarrages rapides Dapr à l’aide de la commande git clone.
```
git clone https://github.com/dapr/quickstarts.git
```
Accédez au répertoire hello-kubernetes à l’aide de cd.
```
cd quickstarts/tutorials/hello-kubernetes/
```

Créer et configurer un magasin d’état

Dapr peut utiliser plusieurs magasins d’état différents comme Redis, Azure Cosmos DB, DynamoDB et Cassandra pour conserver et récupérer l’état. Pour cet exemple, nous allons utiliser Redis.

Créer un magasin Redis

Ouvrez le portail Azure pour démarrer le flux de création d’Azure Cache pour Redis.
Renseignez les informations nécessaires.
Sélectionnez Créer pour démarrer le déploiement instance Redis.
Notez le nom d’hôte de votre instance Redis, que vous pouvez retrouver dans la section Vue d’ensemble dans Azure. Le nom d’hôte peut être similaire à l’exemple suivant : xxxxxx.redis.cache.windows.net:6380.
Sous Paramètres, accédez à Clés d’accès pour obtenir vos clés d’accès.
Créez un secret Kubernetes pour stocker votre mot de passe Redis à l’aide de la commande kubectl create secret generic redis.
```
kubectl create secret generic redis --from-literal=redis-password=<your-redis-password>
```

Configurer les composants Dapr

Une fois votre magasin créé, vous devrez ajouter les clés au fichier redis.yaml dans le répertoire deploy du référentiel Hello World. Vous pouvez en savoir plus ici.

Remplacez la valeur redisHost par votre propre adresse maître Redis.
Remplacez redisPassword par votre propre secret.

Ajoutez les deux lignes suivantes sous redisPassword pour activer la connexion via TLS

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

Appliquer la configuration

Exécutez le fichier redis.yaml à l’aide de la commande kubectl apply.
```
kubectl apply -f ./deploy/redis.yaml
```
Vérifiez que votre magasin d’états a été correctement configuré à l’aide de la commande kubectl get components.redis.
```
kubectl get components.redis -o yaml
```
La sortie devrait ressembler à l’exemple suivant :
```
component.dapr.io/statestore created
```

Déployer l’application Node.js avec le side-car Dapr

Appliquez le déploiement de l’application Node.js à votre cluster avec la commande kubectl apply.
```
kubectl apply -f ./deploy/node.yaml
```
Notes

Les déploiements Kubernetes sont asynchrones, ce qui signifie que vous devrez attendre que le déploiement soit terminé avant de passer aux étapes suivantes. Pour ce faire, utilisez la commande suivante :
```
kubectl rollout status deploy/nodeapp
```
Ceci va déployer l’application Node.js sur Kubernetes. Le plan de contrôle Dapr injectera automatiquement le side-car Dapr dans le pod. Si vous jetez un coup d’œil au fichier node.yaml, vous voyez que l’option Dapr est activée pour ce déploiement :
- dapr.io/enabled: true : indique au plan de contrôle Dapr d’injecter un side-car dans ce déploiement.
- dapr.io/app-id: nodeapp : attribue un ID ou un nom unique à l’application Dapr, afin qu’elle puisse recevoir des messages et communiquer avec d’autres applications Dapr.
Déployez le service à l’aide de la commande kubectl get svc.
```
kubectl get svc nodeapp
```
Notez le EXTERNAL-IP dans la sortie.

Vérifier le service

Appelez le service en utilisant curl avec votre EXTERNAL-IP.
```
curl $EXTERNAL_IP/ports
```
La sortie devrait ressembler à l’exemple suivant :
```
{"DAPR_HTTP_PORT":"3500","DAPR_GRPC_PORT":"50001"}
```

Envoyez un ordre à l’application avec curl.

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

Confirmez la persistance de l’ordre en le demandant avec curl.
```
curl $EXTERNAL_IP/order
```
La sortie devrait ressembler à l’exemple suivant :
```
{ "orderId": "42" }
```

Déployer l’application Python avec le side-car Dapr

Accédez au répertoire de l’application Python dans le démarrage rapide hello-kubernetes et ouvrez app.py.

Cet exemple est une application Python de base qui publie des messages JSON sur localhost:3500, qui est le port d’écoute par défaut de Dapr. Vous pouvez appeler le point de terminaison neworder de l’application Node.js en publiant sur v1.0/invoke/nodeapp/method/neworder. Le message contient des données avec un orderId qui s’incrémente une fois par seconde :
```
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)
```
Déployez l’application Python sur votre cluster Kubernetes avec la commande kubectl apply.
```
kubectl apply -f ./deploy/python.yaml
```
Notes

Comme avec la commande précédente, vous devrez attendre que le déploiement soit terminé avant de passer aux étapes suivantes. Pour ce faire, utilisez la commande suivante :
```
kubectl rollout status deploy/pythonapp
```

Observer les messages et confirmer la persistance

Maintenant que les applications Node.js et Python sont déployées, observez les messages qui arrivent.

Obtenez les journaux de l’application Node.js à l’aide de la commande kubectl logs.

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

Si les déploiements ont réussi, vous devez voir les journaux comme les journaux d’exemple suivants :

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

Appelez le point de terminaison d’ordre de l’application Node.js pour obtenir le dernier ordre avec curl.
```
curl $EXTERNAL_IP/order
{"orderID":"42"}
```
Vous devez voir le code JSON le plus récent dans la réponse.

Supprimez le groupe de ressources, le cluster, l’espace de noms, et toutes les ressources associées à l’aide de la commande az group delete.
```
az group delete --name MyResourceGroup
```

Supprimez le groupe de ressources, le cluster, l’espace de noms, et toutes les ressources associées à l’aide de la commande Remove-AzResourceGroup.
```
Remove-AzResourceGroup -Name MyResourceGroup
```

Étapes suivantes

En savoir plus sur les autres extensions de cluster.