Avvio rapido: Distribuire un'applicazione usando l'estensione del cluster Dapr per il servizio Azure Kubernetes (AKS) o Kubernetes abilitato per Arc

Articolo
08/02/2024

In questo avvio rapido viene usata l'estensione del cluster Dapr in un cluster per il servizio Azure Kubernetes o Kubernetes abilitato per Arc. Viene distribuito un esempio di hello world, costituito da un'applicazione Python che genera messaggi e da un'applicazione node che utilizza e rende persistenti i messaggi.

Prerequisiti

Una sottoscrizione di Azure. Se non hai una sottoscrizione Azure, crea un account gratuito.
Interfaccia della riga di comando di Azure o Azure PowerShell installati.
Un cluster per il servizio Azure Kubernetes o Kubernetes abilitato per Arc con l'estensione per il cluster Dapr abilitato.

Clonare il repository

Clonare il repository di avvii rapidi Dapr usando il comando git clone.
```
git clone https://github.com/dapr/quickstarts.git
```
Passare alla directory hello-kubernetes usando cd.
```
cd quickstarts/tutorials/hello-kubernetes/
```

Creare e configurare un archivio di stati

Dapr può usare molti archivi di stato diversi, ad esempio Redis, Azure Cosmos DB, DynamoDB e Cassandra, per rendere persistente lo stato e recuperarlo. In questo esempio viene usato Redis.

Creare un archivio Redis

Aprire il portale di Azure per avviare il flusso di creazione della cache di Azure per Redis.
Inserire le informazioni necessarie.
Selezionare Crea per avviare la distribuzione dell'istanza di Redis.
Prendere nota del nome host dell'istanza di Redis, che è possibile recuperare dalla sezione Panoramica in Azure. Il nome host sarà simile all'esempio seguente: xxxxxx.redis.cache.windows.net:6380
In Impostazioni, passare a Chiavi di accesso per ottenere le chiavi di accesso.
Creare un segreto di Kubernetes per archiviare la password Redis usando il comando kubectl create secret generic redis.
```
kubectl create secret generic redis --from-literal=redis-password=<your-redis-password>
```

Configurare i componenti Dapr

Dopo aver creato l'archivio, è necessario aggiungere le chiavi al file redis.yaml nella directory di distribuzione del repository Hello World. Altre informazioni sono disponibili qui.

Sostituire il valore redisHost con l'indirizzo master di Redis.
Sostituire redisPassword con il proprio segreto.

Aggiungere le due righe seguenti sotto redisPassword per abilitare la connessione tramite TLS

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

Applicare la configurazione

Applicare il file redis.yaml usando il comando kubectl apply.
```
kubectl apply -f ./deploy/redis.yaml
```
Verificare che l'archivio di stati sia stato configurato correttamente usando il comando kubectl get components.redis.
```
kubectl get components.redis -o yaml
```
L'output dovrebbe essere simile all'output dell'esempio seguente:
```
component.dapr.io/statestore created
```

Distribuire l'app Node.js con il sidecar Dapr

Applicare la distribuzione dell'app Node.js al cluster usando il comando kubectl apply.
```
kubectl apply -f ./deploy/node.yaml
```
Nota

Le distribuzioni Kubernetes sono asincrone, quindi è necessario attenderne il completamento prima di andare ai passaggi successivi. A questo scopo, usare il comando seguente:
```
kubectl rollout status deploy/nodeapp
```
In questo modo l'app Node.js viene distribuita in Kubernetes. Il piano di controllo Dapr inserisce automaticamente il sidecar Dapr nel pod. Se si esamina il file node.yaml, si noterà come la funzionalità Dapr è abilitata per tale distribuzione:
- dapr.io/enabled: true: indica al piano di controllo Dapr di inserire un sidecar in questa distribuzione.
- dapr.io/app-id: nodeapp: assegna un ID o un nome univoco all'applicazione Dapr, in modo che possa ricevere messaggi e comunicare con altre app Dapr.
Accedere al servizio usando il comando kubectl get svc.
```
kubectl get svc nodeapp
```
Prendere nota del valore di EXTERNAL-IP nell'output.

Verificare il servizio

Chiamare il servizio curl con il valore EXTERNAL-IP.
```
curl $EXTERNAL_IP/ports
```
L'output dovrebbe essere simile all'output dell'esempio seguente:
```
{"DAPR_HTTP_PORT":"3500","DAPR_GRPC_PORT":"50001"}
```

Inviare un ordine all'applicazione usando curl.

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

Verificare che l'ordine sia persistente richiedendolo usando curl.
```
curl $EXTERNAL_IP/order
```
L'output dovrebbe essere simile all'output dell'esempio seguente:
```
{ "orderId": "42" }
```

Distribuire l'app Python con il sidecar Dapr

Passare alla directory dell'app Python nell'avvio rapido hello-kubernetes e aprire app.py.

Questo esempio è un'app Python di base che invia messaggi JSON a localhost:3500, ovvero la porta di ascolto predefinita per Dapr. È possibile richiamare l'endpoint neworder dell'applicazione Node.js pubblicando su v1.0/invoke/nodeapp/method/neworder. Il messaggio contiene alcuni dati con un orderId che viene incrementato una volta al secondo:
```
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)
```
Distribuire l'app Python sul cluster Kubernetes usando il comando kubectl apply.
```
kubectl apply -f ./deploy/python.yaml
```
Nota

Come con il comando precedente, è necessario attendere il completamento della distribuzione prima di andare ai passaggi successivi. A questo scopo, usare il comando seguente:
```
kubectl rollout status deploy/pythonapp
```

Osservare i messaggi e confermare la persistenza

Ora che le applicazioni Node.js e Python sono state distribuite, si osservano i messaggi in arrivo.

Ottenere i log dell'app Node.js usando il comando kubectl logs.

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

Se le distribuzioni hanno avuto esito positivo, verranno visualizzati log come quelli dell'esempio seguente:

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

Chiamare l'endpoint dell'ordine dell'app Node.js per ottenere l'ordine più recente usando curl.
```
curl $EXTERNAL_IP/order
{"orderID":"42"}
```
Nella risposta dovrebbe essere visualizzato il file JSON più recente.

Pulire le risorse

Interfaccia della riga di comando di Azure
Azure PowerShell

Rimuovere il gruppo di risorse, il cluster, lo spazio dei nomi e tutte le risorse correlate usando il comando az group delete.
```
az group delete --name MyResourceGroup
```

Passaggi successivi

Informazioni su come creare l'estensione Dapr

Condividi tramite