Szybki start: wdrażanie aplikacji przy użyciu rozszerzenia klastra Dapr dla usługi Azure Kubernetes Service (AKS) lub platformy Kubernetes z obsługą usługi Arc

Artykuł
08/02/2024

W tym przewodniku Szybki start użyjesz rozszerzenia klastra Dapr w klastrze Kubernetes obsługującym usługę AKS lub Arc. Wdrażasz hello world przykład, który składa się z aplikacji w języku Python, która generuje komunikaty i aplikację węzła, która używa i utrwala komunikaty.

Wymagania wstępne

Subskrypcja platformy Azure. Jeśli nie masz subskrypcji Azure, możesz utworzyć bezpłatne konto Azure.
Zainstalowany interfejs wiersza polecenia platformy Azure lub program Azure PowerShell .
Klaster Kubernetes z obsługą usługi AKS lub Arc z włączonym rozszerzeniem klastra Dapr.

Klonowanie repozytorium

Sklonuj repozytorium Szybki start języka Dapr przy użyciu git clone polecenia .
```
git clone https://github.com/dapr/quickstarts.git
```
Przejdź do hello-kubernetes katalogu przy użyciu polecenia cd.
```
cd quickstarts/tutorials/hello-kubernetes/
```

Tworzenie i konfigurowanie magazynu stanów

Język Dapr może używać wielu różnych magazynów stanów, takich jak Redis, Azure Cosmos DB, DynamoDB i Cassandra, do utrwalania i pobierania stanu. W tym przykładzie używamy usługi Redis.

Tworzenie magazynu Redis

Otwórz witrynę Azure Portal, aby uruchomić przepływ tworzenia usługi Azure Cache for Redis.
Wypełnij niezbędne informacje.
Wybierz pozycję Utwórz , aby rozpocząć wdrażanie wystąpienia usługi Redis.
Zanotuj nazwę hosta wystąpienia usługi Redis, którą można pobrać z sekcji Przegląd na platformie Azure. Nazwa hosta może być podobna do następującego przykładu: xxxxxx.redis.cache.windows.net:6380.
W obszarze Ustawienia przejdź do pozycji Klucze dostępu, aby uzyskać klucze dostępu.
Utwórz wpis tajny kubernetes do przechowywania hasła usługi Redis przy użyciu kubectl create secret generic redis polecenia .
```
kubectl create secret generic redis --from-literal=redis-password=<your-redis-password>
```

Konfigurowanie składników języka Dapr

Po utworzeniu magazynu należy dodać klucze do redis.yaml pliku w katalogu deploy repozytorium Hello World . Więcej informacji można znaleźć tutaj.

Zastąp redisHost wartość własnym adresem głównym usługi Redis.
Zastąp element własnym wpisem redisPassword tajnym.

Dodaj następujące dwa wiersze poniżej redisPassword , aby włączyć połączenie za pośrednictwem protokołu TLS

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

Stosowanie konfiguracji

redis.yaml Zastosuj plik przy użyciu kubectl apply polecenia .
```
kubectl apply -f ./deploy/redis.yaml
```
Sprawdź, czy magazyn stanów został pomyślnie skonfigurowany przy użyciu kubectl get components.redis polecenia .
```
kubectl get components.redis -o yaml
```
Powinny zostać wyświetlone dane wyjściowe podobne do następujących przykładowych danych wyjściowych:
```
component.dapr.io/statestore created
```

Wdrażanie aplikacji Node.js za pomocą przyczepki Dapr

Zastosuj wdrożenie aplikacji Node.js do klastra kubectl apply przy użyciu polecenia .
```
kubectl apply -f ./deploy/node.yaml
```
Uwaga

Wdrożenia platformy Kubernetes są asynchroniczne, co oznacza, że musisz poczekać na ukończenie wdrożenia przed przejściem do następnych kroków. Można to zrobić za pomocą następującego polecenia:
```
kubectl rollout status deploy/nodeapp
```
Spowoduje to wdrożenie aplikacji Node.js na platformie Kubernetes. Płaszczyzna sterowania Dapr automatycznie wstrzykuje przyczepkę Dapr do zasobnika. Jeśli przyjrzysz node.yaml się plikowi, zobaczysz, jak język Dapr jest włączony dla tego wdrożenia:
- dapr.io/enabled: true: informuje płaszczyznę sterowania Dapr o wstrzyknięciu przyczepki do tego wdrożenia.
- dapr.io/app-id: nodeapp: przypisuje unikatowy identyfikator lub nazwę do aplikacji Dapr, aby można było wysyłać komunikaty do innych aplikacji Dapr i komunikować się z nimi.
Uzyskaj dostęp do usługi przy użyciu kubectl get svc polecenia .
```
kubectl get svc nodeapp
```
Zanotuj element EXTERNAL-IP w danych wyjściowych.

Weryfikowanie usługi

Wywołaj usługę za pomocą polecenia curl EXTERNAL-IP.
```
curl $EXTERNAL_IP/ports
```
Powinny zostać wyświetlone dane wyjściowe podobne do następujących przykładowych danych wyjściowych:
```
{"DAPR_HTTP_PORT":"3500","DAPR_GRPC_PORT":"50001"}
```

Prześlij zamówienie do aplikacji przy użyciu polecenia curl.

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

Upewnij się, że zamówienie zostało utrwalone, żądając go przy użyciu polecenia curl.
```
curl $EXTERNAL_IP/order
```
Powinny zostać wyświetlone dane wyjściowe podobne do następujących przykładowych danych wyjściowych:
```
{ "orderId": "42" }
```

Wdrażanie aplikacji w języku Python przy użyciu przyczepki języka Dapr

Przejdź do katalogu aplikacji języka Python w przewodniku hello-kubernetes Szybki start i otwórz plik app.py.

W tym przykładzie jest to podstawowa aplikacja w języku Python, która publikuje komunikaty JSON do localhost:3500, która jest domyślnym portem nasłuchiwania dla języka Dapr. Punkt końcowy aplikacji neworder Node.js można wywołać, publikując na v1.0/invoke/nodeapp/method/neworderadres . Komunikat zawiera pewne dane z tym przyrostem orderId raz na 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)
```
Wdróż aplikację w języku Python w klastrze Kubernetes przy użyciu kubectl apply polecenia .
```
kubectl apply -f ./deploy/python.yaml
```
Uwaga

Podobnie jak w przypadku poprzedniego polecenia, należy poczekać na ukończenie wdrożenia przed przejściem do następnych kroków. Można to zrobić za pomocą następującego polecenia:
```
kubectl rollout status deploy/pythonapp
```

Obserwowanie komunikatów i potwierdzanie trwałości

Po wdrożeniu zarówno Node.js, jak i aplikacji języka Python, oglądasz komunikaty przekazywane.

Pobierz dzienniki aplikacji Node.js przy użyciu kubectl logs polecenia .

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

Jeśli wdrożenia zakończyły się pomyślnie, powinny zostać wyświetlone dzienniki podobne do następujących przykładowych dzienników:

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

Wywołaj punkt końcowy zamówienia aplikacji Node.js, aby uzyskać najnowsze zamówienie przy użyciu polecenia curl.
```
curl $EXTERNAL_IP/order
{"orderID":"42"}
```
W odpowiedzi powinien zostać wyświetlony najnowszy kod JSON.

Czyszczenie zasobów

Interfejs wiersza polecenia platformy Azure
Azure PowerShell

Usuń grupę zasobów, klaster, przestrzeń nazw i wszystkie powiązane zasoby przy użyciu polecenia az group delete .
```
az group delete --name MyResourceGroup
```

Następne kroki

Dowiedz się, jak utworzyć rozszerzenie Języka Dapr

Udostępnij za pośrednictwem