Rychlý start: Nasazení aplikace pomocí rozšíření clusteru Dapr pro Azure Kubernetes Service (AKS) nebo Kubernetes s podporou arc

Článek
01/10/2024

V tomto rychlém startu použijete rozšíření clusteru Dapr v clusteru Kubernetes s podporou AKS nebo Arc. Nasadíte hello world příklad, který se skládá z aplikace Pythonu, která generuje zprávy a aplikace uzlu, která zprávy spotřebovává a zachovává.

Požadavky

Předplatné Azure. Pokud ještě nemáte předplatné Azure, můžete si vytvořit bezplatný účet.
Nainstalovali jsme Azure CLI nebo Azure PowerShell .
Cluster Kubernetes s podporou AKS nebo Arc s povoleným rozšířením clusteru Dapr

Klonování úložiště

Naklonujte úložiště rychlých startů Dapr pomocí git clone příkazu.
```
git clone https://github.com/dapr/quickstarts.git
```
Přejděte do hello-kubernetes adresáře pomocí cd.
```
cd quickstarts/tutorials/hello-kubernetes/
```

Vytvoření a konfigurace úložiště stavů

Dapr může k uchování a načtení stavu použít mnoho různých úložišť stavů, jako jsou Redis, Azure Cosmos DB, DynamoDB a Cassandra. V tomto příkladu používáme Redis.

Vytvoření úložiště Redis

Otevřete azure Portal a spusťte tok vytváření Azure Cache for Redis.
Vyplňte potřebné informace.
Výběrem možnosti Vytvořit spusťte nasazení instance Redis.
Poznamenejte si název hostitele vaší instance Redis, který můžete načíst z části Přehled v Azure. Název hostitele může být podobný následujícímu příkladu: xxxxxx.redis.cache.windows.net:6380.
V části Nastavení přejděte na Přístupové klíče a získejte přístupové klíče.
Vytvořte tajný kód Kubernetes pro uložení hesla Redis pomocí kubectl create secret generic redis příkazu.
```
kubectl create secret generic redis --from-literal=redis-password=<your-redis-password>
```

Konfigurace komponent Dapr

Po vytvoření úložiště musíte do redis.yaml souboru přidat klíče v adresáři nasazení úložiště Hello World . Další informace najdete tady.

redisHost Hodnotu nahraďte vlastní hlavní adresou Redis.
redisPassword Nahraďte vlastním tajným kódem.

Přidejte následující dva řádky, redisPassword abyste povolili připojení přes protokol TLS.

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

Použití konfigurace

redis.yaml Použijte soubor pomocí kubectl apply příkazu.
```
kubectl apply -f ./deploy/redis.yaml
```
Pomocí příkazu ověřte, že vaše úložiště stavů bylo úspěšně nakonfigurováno kubectl get components.redis .
```
kubectl get components.redis -o yaml
```
Měl by se zobrazit výstup podobný následujícímu ukázkovém výstupu:
```
component.dapr.io/statestore created
```

Nasazení aplikace Node.js pomocí sajdkáru Dapr

Pomocí příkazu použijte nasazení aplikace Node.js do clusteru kubectl apply .
```
kubectl apply -f ./deploy/node.yaml
```
Poznámka:

Nasazení Kubernetes jsou asynchronní, což znamená, že před přechodem na další kroky musíte počkat na dokončení nasazení. Můžete to udělat pomocí následujícího příkazu:
```
kubectl rollout status deploy/nodeapp
```
Tím se aplikace Node.js nasadí do Kubernetes. Řídicí rovina Dapr automaticky vloží sajdkáru Dapr do podu. Pokud se podíváte na node.yaml soubor, uvidíte, jak je pro toto nasazení povolené Dapr:
- dapr.io/enabled: true: říká řídicí rovině Dapr, aby do tohoto nasazení vkládaly sajdkáru.
- dapr.io/app-id: nodeapp: Přiřadí aplikaci Dapr jedinečné ID nebo název, aby bylo možné odesílat zprávy jiným aplikacím Dapr a komunikovat s ním.
Pomocí příkazu přejděte ke službě kubectl get svc .
```
kubectl get svc nodeapp
```
Poznamenejte EXTERNAL-IP si výstup.

Ověření služby

Zavolejte službu s curl vaším EXTERNAL-IP.
```
curl $EXTERNAL_IP/ports
```
Měl by se zobrazit výstup podobný následujícímu ukázkovém výstupu:
```
{"DAPR_HTTP_PORT":"3500","DAPR_GRPC_PORT":"50001"}
```

Odešlete objednávku do aplikace pomocí curlpříkazu .

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

Potvrďte, že objednávka přetrvává, a to tak, že ji požádáte o použití curl.
```
curl $EXTERNAL_IP/order
```
Měl by se zobrazit výstup podobný následujícímu ukázkovém výstupu:
```
{ "orderId": "42" }
```

Nasazení aplikace v Pythonu pomocí sajdkáru Dapr

V rychlém startu přejděte do adresáře aplikace v Pythonu hello-kubernetes a otevřete app.py.

Tento příklad je základní aplikace Pythonu, která publikuje zprávy JSON do localhost:3500, což je výchozí port naslouchání pro Dapr. Koncový bod aplikace neworder Node.js můžete vyvolat publikováním do v1.0/invoke/nodeapp/method/neworder. Zpráva obsahuje některá data s orderId tím, že se jednou za sekundu zvýší:
```
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)
```
Pomocí příkazu nasaďte aplikaci Python do clusteru kubectl apply Kubernetes.
```
kubectl apply -f ./deploy/python.yaml
```
Poznámka:

Stejně jako u předchozího příkazu musíte počkat, až se nasazení dokončí, než přejdete k dalším krokům. Můžete to udělat pomocí následujícího příkazu:
```
kubectl rollout status deploy/pythonapp
```

Sledování zpráv a potvrzení trvalosti

Teď, když jsou nasazené aplikace Node.js i Pythonu, sledujete, jak přicházejí zprávy.

Pomocí příkazu získejte protokoly aplikace kubectl logs Node.js.

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

Pokud nasazení proběhla úspěšně, měli byste vidět protokoly jako v následujících ukázkových protokolech:

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

Zavolejte koncový bod objednávky aplikace Node.js a získejte tak nejnovější objednávku pomocí curl.
```
curl $EXTERNAL_IP/order
{"orderID":"42"}
```
V odpovědi by se měl zobrazit nejnovější kód JSON.

Pomocí příkazu az group delete odeberte skupinu prostředků, cluster, obor názvů a všechny související prostředky.
```
az group delete --name MyResourceGroup
```

Další kroky

Přečtěte si další informace o dalších rozšířeních clusteru.