Ottimizza lo sviluppo dei microservizi con Dapr e Amazon EKS

I microservizi e i contenitori stanno rivoluzionando il modo in cui vengono costruite, distribuite e gestite le moderne applicazioni nel cloud. Tuttavia, lo sviluppo e il funzionamento dei microservizi possono introdurre una complessità significativa, spesso richiedendo ai sviluppatori di dedicare tempo prezioso a questioni trasversali come la scoperta dei servizi, la gestione dello stato e l’osservabilità.

Dapr, o Distributed Application Runtime, è un runtime open-source per la costruzione di microservizi su cloud e ambienti periferici. Fornisce blocchi di costruzione indipendenti dalla piattaforma come la scoperta dei servizi, la gestione dello stato, la messaggistica pub/sub e l’osservabilità già integrati. Dapr è passato al livello di maturità graduato di CNCF (Cloud Native Computing Foundation) ed è attualmente utilizzato da molte aziende.

Quando combinato con Amazon Elastic Kubernetes Service (Amazon EKS), un servizio Kubernetes gestito da AWS, Dapr può accelerare l’adozione di microservizi e contenitori, consentendo ai sviluppatori di concentrarsi sulla scrittura della logica di business senza preoccuparsi della parte infrastrutturale. Amazon EKS semplifica la gestione dei cluster Kubernetes, consentendo un’escalation senza sforzo mentre i carichi di lavoro cambiano.

In questo post del blog, esploreremo come Dapr semplifica lo sviluppo dei microservizi su Amazon EKS. Inizieremo approfondendo due blocchi di costruzione essenziali:invocazione del servizioegestione dello stato.

Invocazione del Servizio

Una comunicazione fluida e affidabile tra microservizi è fondamentale. Tuttavia, gli sviluppatori spesso si trovano ad affrontare compiti complessi come la scoperta dei servizi, la standardizzazione delle API, la messa in sicurezza dei canali di comunicazione, la gestione dei guasti in modo elegante e l’implementazione dell’osservabilità.

Con l’invocazione del servizio di Dapr, questi problemi diventano un ricordo del passato. I tuoi servizi possono comunicare senza sforzo tra loro utilizzando protocolli standard del settore come gRPC e HTTP/HTTPS. L’invocazione del servizio gestisce tutto il lavoro pesante, dalla registrazione e scoperta dei servizi ai tentativi di richiesta, crittografia, controllo degli accessi e tracciamento distribuito.

Gestione dello stato

Il blocco di costruzione della gestione dello stato di Dapr semplifica il modo in cui gli sviluppatori lavorano con lo stato nelle loro applicazioni. Fornisce un’API coerente per memorizzare e recuperare dati di stato, indipendentemente dallo store di stato sottostante (ad esempio, Redis, AWS DynamoDB, Azure Cosmos DB).

Questa astrazione consente agli sviluppatori di creare applicazioni stateful senza preoccuparsi delle complessità della gestione e della scalabilità degli store di stato.

Prerequisiti

Per seguire questo post, è necessario avere quanto segue:

• Un account AWS. Se non ne hai uno, puoi registrarne uno.
• Un utente IAM con le autorizzazioni appropriate. Il principale di sicurezza IAM che stai utilizzando deve avere il permesso di lavorare con i ruoli IAM di Amazon EKS, i ruoli collegati al servizio, AWS CloudFormation, una VPC e risorse correlate. Per ulteriori informazioni, consulta Azioni, risorse e chiavi di condizione per Amazon Elastic Container Service per Kubernetes e Utilizzo dei ruoli collegati al servizio nella Guida utente di AWS Identity and Access Management.

Architettura dell’applicazione

Nel diagramma qui sotto, abbiamo due microservizi: un’app Python e un’app Node.js. L’app Python genera dati sugli ordini e invoca l’endpoint /neworder esposto dall’app Node.js. L’app Node.js scrive i dati degli ordini in arrivo in uno stato di archiviazione (in questo caso, Amazon ElastiCache) e restituisce un ID ordine all’app Python come risposta.

Sfruttando il blocco di costruzione per l’invocazione dei servizi di Dapr, l’app Python può comunicare senza problemi con l’app Node.js senza preoccuparsi della scoperta dei servizi, della standardizzazione delle API, della sicurezza del canale di comunicazione, della gestione dei guasti o dell’osservabilità. Implementa mTLS per fornire comunicazione sicura da servizio a servizio.

Dapr gestisce queste preoccupazioni trasversali, consentendo agli sviluppatori di concentrarsi sulla scrittura della logica aziendale fondamentale.

Inoltre, il blocco di costruzione per la gestione dello stato di Dapr semplifica il modo in cui l’app Node.js interagisce con il negozio di stato (Amazon ElastiCache). Dapr fornisce un’API coerente per memorizzare e recuperare dati di stato, astraiendo le complessità della gestione e della scalabilità del negozio di stato sottostante. Questa astrazione consente agli sviluppatori di creare applicazioni con stato senza preoccuparsi delle complessità della gestione del negozio di stato.

Il cluster Amazon EKS ospita uno spazio dei nomi chiamato dapr-system, che contiene i componenti del piano di controllo di Dapr. Il dapr-sidecar-injector inietta automaticamente un runtime di Dapr nei pod dei microservizi abilitati a Dapr.

Passaggi di invocazione del servizio

1. Il servizio generatore di ordini (app Python) invoca il metodo dell’app Node, /neworder. Questa richiesta viene inviata al sidecar di Dapr locale, che viene eseguito nello stesso pod dell’app Python. 
2. Dapr risolve l’applicazione di destinazione utilizzando il provider DNS del cluster Amazon EKS e invia la richiesta al sidecar dell’app Node. 
3. Il sidecar dell’app Node invia quindi la richiesta al microservizio dell’app Node. 
4. L’app Node scrive quindi l’ID ordine ricevuto dall’app Python su Amazon ElasticCache.
5. L’app Node invia la risposta al suo sidecar di Dapr locale. 
6. Il sidecar dell’app Node inoltra la risposta al sidecar di Dapr dell’app Python. 
7. Il sidecar dell’app Python restituisce la risposta all’app Python, che aveva avviato la richiesta al metodo dell’app Node /neworder. 

Passaggi di distribuzione

Crea e Conferma un Cluster EKS

Per impostare un Amazon EKS (Elastic Kubernetes Service) cluster, dovrai seguire diversi passaggi. Ecco una panoramica del processo:

Requisiti

• Installa e configura l’AWS CLI
• Installa eksctl, kubectl e AWS IAM Authenticator

1. Crea un cluster EKS. Usa eksctl per creare un cluster di base con un comando come:

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

2. Configura kubectl. Aggiorna il tuo kubeconfig per connetterti al nuovo cluster:

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

3. Verifica il cluster. Controlla se i tuoi nodi sono pronti:

kubectl get nodes

Installa DAPR sul tuo cluster EKS

1. Installa DAPR CLI:

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

2. Verifica l’installazione:

dapr -h

3. Installa DAPR e valida:

dapr init -k --dev

dapr status -k

I componenti Dapr statestore e pubsub vengono creati nel namespace predefinito. Puoi verificarlo usando il comando sottostante:

dapr components -k

Configura Amazon ElastiCache come il tuo Dapr StateStore

Crea Amazon ElastiCache per memorizzare lo stato per il microservizio. In questo esempio, stiamo utilizzando ElastiCache senza server, che crea rapidamente una cache che si scala automaticamente per soddisfare le esigenze di traffico dell’applicazione senza server da gestire.

Configurare il gruppo di sicurezza dell’ElastiCache per consentire connessioni dal cluster EKS. Per semplicità, mantienilo nella stessa VPC del tuo cluster EKS. Prendi nota del punto di accesso della cache, che ci servirà per i passaggi successivi.

Esecuzione di un’applicazione di esempio

1. Clonare il repository Git dell’applicazione di esempio:

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

2. Creare redis-state.yaml e fornire un endpoint di Amazon ElasticCache per 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 

​

Applicare la configurazione yaml per il componente di archiviazione di stato utilizzando kubectl.

kubectl apply -f redis-state.yaml

3. Distribuire i microservizi con il sidecar. 

Per l’applicazione del nodo del microservizio, navigare nel file /quickstarts/tutorials/hello-kubernetes/deploy/node.yaml e noterai le annotazioni seguenti. Indica al piano di controllo di Dapr di iniettare un sidecar e assegna anche un nome all’applicazione di Dapr.

annotations:

        dapr.io/enabled: "true"

        dapr.io/app-id: "nodeapp"

        dapr.io/app-port: "3000"

​

Aggiungere un’annotazione service.beta.kubernetes.io/aws-load-balancer-scheme: “internet-facing” in node.yaml per creare un 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

​

Implementare l’applicazione del nodo utilizzando kubectl. Navigare nella directory /quickstarts/tutorials/hello-kubernetes/deploy ed eseguire il comando seguente.

kubectl apply -f node.yaml

Ottenere il AWS NLB, che appare sotto External IP, nell’output del comando seguente. 

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

Navigare nella directory /quickstarts/tutorials/hello-kubernetes, che contiene il file sample.json per eseguire il passaggio seguente.

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

È possibile verificare l’output accedendo all’endpoint /order utilizzando il bilanciamento del carico in un browser.

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

Vedrai l’output come {“OrderId”:“42”}

Successivamente, distribuisci la seconda app Python del microservizio, che ha una logica di business per generare un nuovo ID ordine ogni secondo e invocare il metodo dell’app Node /neworder.

Naviga nella directory /quickstarts/tutorials/hello-kubernetes/deploy ed esegui il comando sottostante.

kubectl apply -f python.yaml

4. Conferma e testa la distribuzione dell’applicazione.

Ora che entrambi i microservizi sono stati distribuiti. L’app Python sta generando ordini e invocando /neworder come evidenziato dai log qui sotto.

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

Possiamo vedere che l’app Node sta ricevendo le richieste e scrivendo nello store di stato Amazon ElasticCache nel nostro esempio. 

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

Per confermare se i dati sono persistiti in Amazon ElasticCache accediamo all’endpoint /order qui sotto. Restituisce l’ultimo ID ordine, generato dall’app Python.

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

Vedrai in output l’ordine più recente come {“OrderId”:“370”}. 

Pulizia

Esegui il comando sottostante per eliminare le distribuzioni dell’app Node e dell’app Python insieme al componente store di stato. 

Naviga nella directory /quickstarts/tutorials/hello-kubernetes/deploy per eseguire il comando qui sotto.

kubectl delete -f node.yaml

kubectl delete -f python.yaml

Puoi smantellare il tuo cluster EKS utilizzando il comando eksctl ed eliminare Amazon ElastiCache.

Naviga nella directory che contiene il file cluster.yaml utilizzato per creare il cluster nel primo passaggio.

eksctl delete cluster -f cluster.yaml

Conclusione

Dapr e Amazon EKS formano un potente alleanza per lo sviluppo di microservizi. Dapr semplifica le preoccupazioni trasversali, mentre EKS gestisce l’infrastruttura Kubernetes, consentendo agli sviluppatori di concentrarsi sulla logica aziendale principale e aumentare la produttività.

Questa combinazione accelera la creazione di applicazioni scalabili, resilienti e osservabili, riducendo significativamente i costi operativi. È una base ideale per il tuo viaggio nei microservizi. Tieni d’occhio i prossimi post che esploreranno le capacità di Dapr ed EKS nel tracciamento distribuito e nell’osservabilità, offrendo approfondimenti e best practices.