Otimize o Desenvolvimento de Microservices com Dapr e Amazon EKS

Microserviços e contêineres estão revolucionando a forma como aplicações modernas são construídas, implantadas e gerenciadas na nuvem. No entanto, desenvolver e operar microserviços pode introduzir uma complexidade significativa, muitas vezes exigindo que os desenvolvedores gastem um tempo valioso em preocupações transversais como descoberta de serviços, gerenciamento de estado e observabilidade.

Dapr, ou Runtime de Aplicações Distribuídas, é um runtime de código aberto para a construção de microserviços em ambientes de nuvem e de borda. Ele fornece blocos de construção independentes de plataforma, como descoberta de serviços, gerenciamento de estado, mensagens pub/sub e observabilidade prontamente disponíveis. Dapr alcançou o nível de maturidade graduado da CNCF (Cloud Native Computing Foundation) e é atualmente utilizado por muitas empresas.

Quando combinado com o Amazon Elastic Kubernetes Service (Amazon EKS), um serviço gerenciado de Kubernetes da AWS, Dapr pode acelerar a adoção de microserviços e contêineres, permitindo que os desenvolvedores se concentrem em escrever lógica de negócios sem se preocupar com a infraestrutura. O Amazon EKS torna a gestão de clusters Kubernetes fácil, permitindo escalabilidade sem esforço à medida que as cargas de trabalho mudam.

Neste post do blog, exploraremos como o Dapr simplifica o desenvolvimento de microserviços no Amazon EKS. Começaremos mergulhando em dois blocos de construção essenciais: invocação de serviços e gerenciamento de estado.

Invocação de Serviço

Uma comunicação contínua e confiável entre microsserviços é crucial. No entanto, os desenvolvedores frequentemente enfrentam desafios complexos como descoberta de serviço, padronização de APIs, segurança de canais de comunicação, tratamento gracioso de falhas e implementação de observabilidade.

Com a invocação de serviço do Dapr, esses problemas se tornam coisa do passado. Seus serviços podem se comunicar facilmente uns com os outros utilizando protocolos padrão da indústria como gRPC e HTTP/HTTPS. A invocação de serviço lida com todo o trabalho pesado, desde o registro e descoberta de serviço até as tentativas de requisição, criptografia, controle de acesso e rastreamento distribuído.

Gestão de Estado

O bloco de construção de gestão de estado do Dapr simplifica a forma como os desenvolvedores trabalham com o estado em suas aplicações. Ele fornece uma API consistente para armazenar e recuperar dados de estado, independentemente da loja de estado subjacente (por exemplo, Redis, AWS DynamoDB, Azure Cosmos DB).

Essa abstração permite aos desenvolvedores construir aplicações com estado sem se preocupar com as complexidades de gerenciar e dimensionar lojas de estado.

Pré-requisitos

Para seguir esta postagem, você deve ter o seguinte:

• Uma conta AWS. Se você não tiver uma, pode criar uma.
• Um usuário IAM com permissões adequadas. O principal de segurança do IAM que você está usando deve ter permissão para trabalhar com funções IAM do Amazon EKS, funções vinculadas ao serviço, AWS CloudFormation, uma VPC e recursos relacionados. Para obter mais informações, consulte Ações, recursos e chaves de condição para o Amazon Elastic Container Service for Kubernetes e Usando funções vinculadas ao serviço no Guia do Usuário do AWS Identity and Access Management.

Arquitetura de Aplicativo

No diagrama abaixo, temos dois microsserviços: um aplicativo Python e um aplicativo Node.js. O aplicativo Python gera dados de pedidos e invoca o endpoint /neworder exposto pelo aplicativo Node.js. O aplicativo Node.js escreve os dados de pedidos recebidos em um armazenamento de estado (neste caso, Amazon ElastiCache) e retorna um ID de pedido para o aplicativo Python como resposta.

Ao aproveitar o bloco de construção de invocação de serviço do Dapr, o aplicativo Python pode se comunicar perfeitamente com o aplicativo Node.js sem se preocupar com descoberta de serviço, padronização de API, segurança de canal de comunicação, tratamento de falhas ou observabilidade. Ele implementa mTLS para fornecer comunicação segura entre serviços.

O Dapr lida com essas preocupações transversais, permitindo que os desenvolvedores se concentrem em escrever a lógica de negócios central.

Além disso, o bloco de construção de gerenciamento de estado do Dapr simplifica a interação do aplicativo Node.js com o armazenamento de estado (Amazon ElastiCache). O Dapr fornece uma API consistente para armazenar e recuperar dados de estado, abstraindo as complexidades de gerenciar e escalar o armazenamento de estado subjacente. Essa abstração permite que os desenvolvedores construam aplicações com estado sem se preocupar com as intricacias do gerenciamento do armazenamento de estado.

O cluster Amazon EKS hospeda um namespace chamado dapr-system, que contém os componentes do plano de controle do Dapr. O dapr-sidecar-injector injeta automaticamente um runtime do Dapr nos pods de microsserviços habilitados para Dapr.

Passos de Invocação de Serviço

1. O serviço gerador de pedidos (aplicativo Python) invoca o método do aplicativo Node, /neworder. Essa solicitação é enviada para o sidecar local do Dapr, que está executando no mesmo pod que o aplicativo Python.
2. O Dapr resolve o aplicativo de destino usando o provedor de DNS do cluster Amazon EKS e envia a solicitação para o sidecar do aplicativo Node.
3. O sidecar do aplicativo Node então envia a solicitação para o microsserviço do aplicativo Node.
4. O aplicativo Node então grava o ID do pedido recebido do aplicativo Python no Amazon ElasticCache.
5. O aplicativo Node envia a resposta para seu sidecar local do Dapr.
6. O sidecar do aplicativo Node encaminha a resposta para o sidecar do Dapr do aplicativo Python.
7. O sidecar do aplicativo Python retorna a resposta para o aplicativo Python, que havia iniciado a solicitação para o método do aplicativo Node /neworder.

Passos de Implantação

Crie e Confirme um Cluster EKS

Para configurar um Amazon EKS (Elastic Kubernetes Service), você precisará seguir várias etapas. Aqui está uma visão geral do processo:

Pré-requisitos

• Instale e configure a AWS CLI
• Instale eksctl, kubectl e AWS IAM Authenticator

1. Crie um cluster EKS. Use eksctl para criar um cluster básico com um comando como:

eksctl create cluster --name my-cluster --region us-west-2 --node-type t3.medium --nodes 3

2. Configure o kubectl. Atualize seu kubeconfig para conectar-se ao novo cluster:

aws eks update-kubeconfig --name my-cluster --region us-west-2

3. Verifique o cluster. Verifique se seus nós estão prontos:

kubectl get nodes

Instale o DAPR no seu cluster EKS

1. Instale o DAPR CLI:

wget -q https://raw.githubusercontent.com/dapr/cli/master/install/install.sh -O - | /bin/bash

2. Verifique a instalação:

dapr -h

3. Instale o DAPR e valide:

dapr init -k --dev

dapr status -k

Os componentes do Dapr statestore e pubsub são criados no namespace padrão. Você pode verificar isso usando o comando abaixo:

dapr components -k

Configure o Amazon ElastiCache como seu Dapr StateStore

Crie o Amazon ElastiCache para armazenar o estado do microserviço. Neste exemplo, estamos usando o ElastiCache sem servidor, que rapidamente cria um cache que escala automaticamente para atender à demanda de tráfego da aplicação, sem servidores para gerenciar.

Configure o grupo de segurança do ElastiCache para permitir conexões do seu cluster EKS. Para facilitar, mantenha-o na mesma VPC que seu cluster EKS. Tome nota do endpoint de cache, que precisaremos para os próximos passos.

Executando uma Aplicação de Exemplo

1. Clone o repositório Git da aplicação de exemplo:

git clone https://github.com/dapr/quickstarts.git

2. Crie redis-state.yaml e forneça um endpoint do Amazon ElasticCache para redisHost:

apiVersion: dapr.io/v1alpha1

kind: Component

metadata:

  name: statestore

  namespace: default

spec:

  type: state.redis

  version: v1

  metadata:

  - name: redisHost

    value: redisdaprd-7rr0vd.serverless.use1.cache.amazonaws.com:6379

  - name: enableTLS

    value: true 

​

Aplique a configuração yaml para o componente de armazenamento de estado usando kubectl.

kubectl apply -f redis-state.yaml

3. Implante microserviços com o sidecar.

Para o aplicativo de nó do microserviço, acesse o arquivo /quickstarts/tutorials/hello-kubernetes/deploy/node.yaml e você notará as seguintes anotações. Elas dizem ao plano de controle do Dapr para injetar um sidecar e também atribuem um nome à aplicação Dapr.

annotations:

        dapr.io/enabled: "true"

        dapr.io/app-id: "nodeapp"

        dapr.io/app-port: "3000"

​

Adicione uma anotação service.beta.kubernetes.io/aws-load-balancer-scheme: “internet-facing” em node.yaml para criar um AWS ELB.

kind: Service

apiVersion: v1

metadata:

  name: nodeapp

  annotations:

    service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing"

  labels:

    app: node

spec:

  selector:

    app: node

  ports:

  - protocol: TCP

    port: 80

    targetPort: 3000

  type: LoadBalancer

​

Implante o aplicativo de nó usando kubectl. Acesse o diretório /quickstarts/tutorials/hello-kubernetes/deploy e execute o comando abaixo.

kubectl apply -f node.yaml

Obtenha o AWS NLB, que aparece sob o IP externo, na saída do comando abaixo.

kubectl get svc nodeapp http://k8s-default-nodeapp-3a173e0d55-f7b14bedf0c4dd8.elb.us-east-1.amazonaws.com

Acesse o diretório /quickstarts/tutorials/hello-kubernetes, que possui o arquivo sample.json para executar o próximo passo.

curl --request POST --data "@sample.json" --header Content-Type:application/json http://k8s-default-nodeapp-3a173e0d55-f14bedff0c4dd8.elb.us-east-1.amazonaws.com/neworder

Você pode verificar a saída acessando o endpoint /order usando o balanceador de carga em um navegador.

http://k8s-default-nodeapp-3a173e0d55-f7b14bedff0c4dd8.elb.us-east-1.amazonaws.com/order

Você verá a saída como {“OrderId”:“42”}

Em seguida, implante o segundo aplicativo microserviço em Python, que possui uma lógica de negócios para gerar um novo ID de pedido a cada segundo e invocar o método do aplicativo Node /neworder.

Navegue até o diretório /quickstarts/tutorials/hello-kubernetes/deploy e execute o comando abaixo.

kubectl apply -f python.yaml

4. Validando e testando a implantação do seu aplicativo.

Agora que temos ambos os microserviços implantados. O aplicativo Python está gerando pedidos e invocando /neworder, como é evidente pelos logs abaixo.

kubectl logs --selector=app=python -c daprd --tail=-1

time="2024-03-07T12:43:11.556356346Z" level=info msg="HTTP API Called" app_id=pythonapp instance=pythonapp-974db9877-dljtw method="POST /neworder" scope=dapr.runtime.http-info type=log useragent=python-requests/2.31.0 ver=1.12.5

time="2024-03-07T12:43:12.563193147Z" level=info msg="HTTP API Called" app_id=pythonapp instance=pythonapp-974db9877-dljtw method="POST /neworder" scope=dapr.runtime.http-info type=log useragent=python-requests/2.31.0 ver=1.12.5

Podemos ver que o aplicativo Node está recebendo as solicitações e escrevendo no armazenamento de estado Amazon ElasticCache em nosso exemplo.

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

Got a new order! Order ID: 367

Successfully persisted state for Order ID: 367

Got a new order! Order ID: 368

Successfully persisted state for Order ID: 368

Got a new order! Order ID: 369

Successfully persisted state for Order ID: 369

Para confirmar se os dados estão persistidos no Amazon ElasticCache, acessamos o endpoint /order abaixo. Ele retorna o ID do pedido mais recente, que foi gerado pelo aplicativo Python.

http://k8s-default-nodeapp-3a173e0d55-f7b14beff0c4dd8.elb.us-east-1.amazonaws.com/order

Você verá uma saída com o pedido mais recente como {“OrderId”:“370”}.

Limpeza

Execute o comando abaixo para excluir as implantações do aplicativo Node e do aplicativo Python, juntamente com o componente de armazenamento de estado.

Navegue até o diretório /quickstarts/tutorials/hello-kubernetes/deploy para executar o comando abaixo.

kubectl delete -f node.yaml

kubectl delete -f python.yaml

Você pode desmontar seu cluster EKS usando o comando eksctl e excluir o Amazon ElastiCache.

Navegue até o diretório que possui o arquivo cluster.yaml usado para criar o cluster na primeira etapa.

eksctl delete cluster -f cluster.yaml

Conclusão

Dapr e Amazon EKS formam uma poderosa aliança para o desenvolvimento de microsserviços. Dapr simplifica preocupações transversais, enquanto o EKS gerencia a infraestrutura do Kubernetes, permitindo que os desenvolvedores foquem na lógica central do negócio e aumentem a produtividade.

Essa combinação acelera a criação de aplicações escaláveis, resilientes e observáveis, reduzindo significativamente a sobrecarga operacional. É uma base ideal para a jornada dos seus microsserviços. Fique atento para futuras postagens explorando as capacidades de Dapr e EKS em rastreamento distribuído e observabilidade, oferecendo insights mais profundos e melhores práticas.