Início Rápido: implantar um aplicativo usando a extensão de cluster do Dapr para o AKS (Serviço de Kubernetes do Azure) ou Kubernetes habilitado para o Arc

Artigo
01/23/2024

Neste início rápido, você usará a extensão de cluster do Dapr em um cluster do Kubernetes habilitado para o AKS ou Arc. Você implanta um exemplo hello world, que consiste em um aplicativo Python que gera mensagens e um aplicativo de nó que consome e persiste as mensagens.

Pré-requisitos

Uma assinatura do Azure. Caso não tenha uma assinatura do Azure, é possível criar uma conta gratuita.
CLI do Azure ou Azure PowerShell instalados.
Um cluster do Kubernetes habilitado para o AKS ou Arc com a extensão de cluster do Dapr habilitada.

Clonar o repositório

Clone o repositório Inícios rápidos do Dapr usando o comando git clone.
```
git clone https://github.com/dapr/quickstarts.git
```
Altere para o diretório hello-kubernetes usando cd.
```
cd quickstarts/tutorials/hello-kubernetes/
```

Criar e configurar um repositório de estado

O Dapr pode usar vários repositórios de estado diferentes, como o Redis, o Azure Cosmos DB, o DynamoDB e o Cassandra, para persistir e recuperar o estado. Para este exemplo, vamos usar o Redis.

Criar um repositório Redis

Abra o portal do Azure para iniciar o fluxo de criação do Cache do Azure para Redis.
Preencha as informações necessárias.
Selecione criar para iniciar a implantação da instância do Redis.
Anote o nome do host da instância do Redis, que você pode recuperar da seção Visão geral no Azure. O nome do host pode ser semelhante ao exemplo a seguir: xxxxxx.redis.cache.windows.net:6380.
Em Configurações, navegue até Chaves de acesso para obter as chaves de acesso.
Crie um segredo do Kubernetes para armazenar sua senha do Redis com o comando kubectl create secret generic redis.
```
kubectl create secret generic redis --from-literal=redis-password=<your-redis-password>
```

Configurar os componentes da Dapr

Depois que sua loja for criada, você precisará adicionar as chaves ao arquivo redis.yaml no diretório de implantação do repositório Olá, Mundo. Você pode saber mais aqui.

Substitua o valor redisHost por seu próprio endereço mestre do Redis.
Substitua o redisPassword por seu próprio Segredo.

Adicione as duas linhas a seguir abaixo de redisPassword para habilitar a conexão por TLS

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

Aplicar a configuração

Aplique o arquivo redis.yaml usando o comando kubectl apply.
```
kubectl apply -f ./deploy/redis.yaml
```
Verifique se o armazenamento do estado foi configurado com êxito usando o comando kubectl get components.redis.
```
kubectl get components.redis -o yaml
```
Você deverá ver uma saída semelhante à do exemplo a seguir:
```
component.dapr.io/statestore created
```

Implantar o aplicativo Node.js com o sidecar do Dapr

Aplique a implantação do aplicativo Node.js ao seu cluster com o comando kubectl apply.
```
kubectl apply -f ./deploy/node.yaml
```
Observação

As implantações do Kubernetes são assíncronas, o que significa que você precisa aguardar a conclusão da implantação antes de passar para as próximas etapas. Você pode fazer isso com o seguinte comando:
```
kubectl rollout status deploy/nodeapp
```
Isso implanta o aplicativo Node.js no Kubernetes. O plano de controle do Dapr injeta automaticamente o sidecar do Dapr no Pod. Se você der uma olhada no arquivo node.yaml, verá como o Dapr está habilitado para essa implantação:
- dapr.io/enabled: true: informa ao plano de controle do Dapr para injetar um sidecar nessa implantação.
- dapr.io/app-id: nodeapp: atribui uma ID ou nome exclusivo ao aplicativo do Dapr, para que ele possa receber mensagens e se comunicar com outros aplicativos do Dapr.
Acesse seu serviço usando o comando kubectl get svc.
```
kubectl get svc nodeapp
```
Anote o EXTERNAL-IP na saída.

Verificar o serviço

Chamar o serviço usando curl com seu EXTERNAL-IP.
```
curl $EXTERNAL_IP/ports
```
Você deverá ver uma saída semelhante à do exemplo a seguir:
```
{"DAPR_HTTP_PORT":"3500","DAPR_GRPC_PORT":"50001"}
```

Envie um pedido para o aplicativo usando curl.

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

Confirme se o pedido persistiu solicitando-o usando curl.
```
curl $EXTERNAL_IP/order
```
Você deverá ver uma saída semelhante à do exemplo a seguir:
```
{ "orderId": "42" }
```

Implantar o aplicativo Python com o sidecar do Dapr

Navegue até o diretório do aplicativo Python no início rápido hello-kubernetes e abra app.py.

Este exemplo é um aplicativo Python básico que posta mensagens JSON em localhost:3500, que é a porta de escuta padrão para Dapr. Postando em v1.0/invoke/nodeapp/method/neworder, você pode invocar o ponto de extremidade neworder do aplicativo Node.js. A mensagem contém alguns dados com um orderId que é incrementado uma vez por segundo:
```
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)
```
Implemente o aplicativo Python em seu cluster do Kubernetes com o comando kubectl apply.
```
kubectl apply -f ./deploy/python.yaml
```
Observação

Tal como acontece com o comando anterior, você precisa aguardar a conclusão da implantação antes de passar para as próximas etapas. Você pode fazer isso com o seguinte comando:
```
kubectl rollout status deploy/pythonapp
```

Observar mensagens e confirmar a persistência

Agora que os aplicativos Node.js e Python estão implantados, você pode ver as mensagens chegando.

Obtenha os logs do aplicativo Node.js usando o comando kubectl logs.

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

Se as implantações forem bem-sucedidas, você verá logs como os do exemplo a seguir:

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

Chama o ponto de extremidade do pedido do aplicativo Node.js para obter o pedido mais recente usando curl.
```
curl $EXTERNAL_IP/order
{"orderID":"42"}
```
O JSON mais recente deverá aparecer na resposta.

Remova o grupo de recursos, o cluster, o namespace e todos os recursos relacionados usando o comando az group delete.
```
az group delete --name MyResourceGroup
```

Próximas etapas

Saiba mais sobre outras extensões do cluster.