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

Artigo
01/23/2024

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

Pré-requisitos

Uma subscrição do Azure. Se não tiver uma subscrição do Azure, pode criar uma conta gratuita.
CLI do Azure ou Azure PowerShell instalado.
Um cluster Kubernetes habilitado para AKS ou Arc com a extensão de cluster Dapr habilitada.

Clonar o repositório

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

Criar e configurar um repositório de estado

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

Criar uma loja 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 Redis.
Anote o nome do host da sua instância do Redis, que você pode recuperar na 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é Teclas de acesso para obter suas chaves de acesso.
Crie um segredo do Kubernetes para armazenar sua senha Redis usando o kubectl create secret generic redis comando.
```
kubectl create secret generic redis --from-literal=redis-password=<your-redis-password>
```

Configurar os componentes do Dapr

Depois que sua loja for criada, você precisará adicionar as chaves ao redis.yaml arquivo no diretório deploy do repositório Hello World . Saiba mais aqui.

Substitua o redisHost valor pelo seu próprio endereço mestre Redis.
Substitua o redisPassword por seu próprio segredo.

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

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

Aplicar a configuração

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

Implante o aplicativo Node.js com o sidecar Dapr

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

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 Dapr injeta automaticamente o sidecar Dapr no Pod. Se você der uma olhada no arquivo, verá como o node.yaml Dapr está habilitado para essa implantação:
- dapr.io/enabled: true: diz ao avião de controle Dapr para injetar um sidecar nesta implantação.
- dapr.io/app-id: nodeapp: atribui um ID ou nome exclusivo ao aplicativo Dapr, para que ele possa ser enviado e comunicado por outros aplicativos Dapr.
Acesse seu serviço usando o kubectl get svc comando.
```
kubectl get svc nodeapp
```
Anote o EXTERNAL-IP na saída.

Verificar o serviço

Ligue para o serviço usando curl o seu EXTERNAL-IParquivo .
```
curl $EXTERNAL_IP/ports
```
Você deve ver uma saída semelhante à saída de exemplo a seguir:
```
{"DAPR_HTTP_PORT":"3500","DAPR_GRPC_PORT":"50001"}
```

Envie um pedido para o aplicativo usando curlo .

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

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

Implante o aplicativo Python com o sidecar Dapr

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

Este exemplo é um aplicativo Python básico que posta mensagens JSON no localhost:3500, que é a porta de escuta padrão para o Dapr. Você pode invocar o ponto de extremidade do neworder aplicativo Node.js postando em v1.0/invoke/nodeapp/method/neworder. A mensagem contém alguns dados com um orderId incremento que aumenta 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)
```
Implante o aplicativo Python em seu cluster Kubernetes usando o kubectl apply comando.
```
kubectl apply -f ./deploy/python.yaml
```
Nota

Assim como no 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
```

Observe as mensagens e confirme a persistência

Agora que os aplicativos Node.js e Python estão implantados, você vê as mensagens chegarem.

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

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

Se as implantações foram bem-sucedidas, você verá logs como os seguintes logs de exemplo:

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

Chame o ponto de extremidade de pedido do aplicativo Node.js para obter o pedido mais recente usando curlo .
```
curl $EXTERNAL_IP/order
{"orderID":"42"}
```
Você deve ver o JSON mais recente na resposta.

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

Próximos passos

Saiba mais sobre outras extensões de cluster.