Vereenvoudig de ontwikkeling van Microservices met Dapr en Amazon EKS

Microservices en containers revolutioneren hoe moderne applicaties worden gebouwd, ingezet en beheerd in de cloud. Echter, het ontwikkelen en bedienen van microservices kan aanzienlijke complexiteit met zich meebrengen, waarbij ontwikkelaars vaak waardevolle tijd moeten besteden aan zaken als serviceontdekking, toestandsbeheer en observeerbaarheid.

Dapr, of Distributed Application Runtime, is een open-source runtime voor het bouwen van microservices in cloud- en edge-omgevingen. Het biedt platformagnostische bouwstenen zoals serviceontdekking, toestandsbeheer, publicatie/abonnement-messaging en observeerbaarheid direct uit de doos. Dapr is overgegaan naar het volwassenheidsniveau van CNCF (Cloud Native Computing Foundation) en wordt momenteel gebruikt door vele bedrijven.

In combinatie met Amazon Elastic Kubernetes Service (Amazon EKS), een beheerde Kubernetes-service van AWS, kan Dapr de adoptie van microservices en containers versnellen, waardoor ontwikkelaars zich kunnen richten op het schrijven van bedrijfslogica zonder zich zorgen te hoeven maken over de infrastructuur. Amazon EKS maakt het beheren van Kubernetes-clusters eenvoudig en maakt moeiteloos schalen mogelijk naarmate de werklasten veranderen.

In deze blogpost zullen we onderzoeken hoe Dapr de ontwikkeling van microservices op Amazon EKS vereenvoudigt. We zullen beginnen met het verkennen van twee essentiële bouwstenen: serviceoproep en toestandsbeheer .

Service-aanroep

Naadloze en betrouwbare communicatie tussen microservices is cruciaal. Ontwikkelaars hebben echter vaak moeite met complexe taken zoals serviceontdekking, het standaardiseren van API’s, het beveiligen van communicatiekanalen, het netjes afhandelen van fouten en het implementeren van observability.

Met Dapr’s service-aanroep worden deze problemen een verleden tijd. Uw services kunnen moeiteloos met elkaar communiceren met behulp van industriestandaardprotocollen zoals gRPC en HTTP/HTTPS. Service-aanroep neemt al het zware werk op zich, van service-registratie en -ontdekking tot verzoekherhalingen, versleuteling, toegangscontrole en gedistribueerde tracing.

Staatbeheer

Het staatbeheer blok van Dapr vereenvoudigt de manier waarop ontwikkelaars werken met de staat in hun applicaties. Het biedt een consistente API voor het opslaan en ophalen van staatgegevens, ongeacht de onderliggende staatopslag (bijv. Redis, AWS DynamoDB, Azure Cosmos DB).

Deze abstractie stelt ontwikkelaars in staat om staatshoudende applicaties te bouwen zonder zich zorgen te hoeven maken over de complexiteit van het beheren en schalen van staatopslag.

Vereisten

Om dit bericht te volgen, moet je het volgende hebben:

• Een AWS-account. Als je dat niet hebt, kun je er een aanmaken.
• Een IAM-gebruiker met de juiste machtigingen. Het IAM-beveiligingsprincipe dat je gebruikt moet toestemming hebben om te werken met Amazon EKS IAM-rollen, service-gekoppelde rollen, AWS CloudFormation, een VPC en gerelateerde middelen. Voor meer informatie, zie Acties, middelen en voorwaardelijke sleutels voor Amazon Elastic Container Service voor Kubernetes en Gebruik van service-gekoppelde rollen in de AWS Identity and Access Management Gebruikershandleiding.

Toepassingsarchitectuur

In het onderstaande diagram hebben we twee microservices: een Python-app en een Node.js-app. De Python-app genereert ordergegevens en roept de /neworder endpoint aan die door de Node.js-app wordt blootgesteld. De Node.js-app schrijft de binnenkomende ordergegevens naar een statusopslag (in dit geval, Amazon ElastiCache) en retourneert een order-ID aan de Python-app als reactie.

Door gebruik te maken van Dapr’s service-aanroep bouwsteen kan de Python-app naadloos communiceren met de Node.js-app zonder zich zorgen te maken over serviceontdekking, API-standaardisatie, beveiliging van communicatiekanalen, foutafhandeling of observeerbaarheid. Het implementeert mTLS om veilige communicatie van service tot service te bieden.

Dapr behandelt deze dwarsdoorsnijdende zorgen, waardoor ontwikkelaars zich kunnen concentreren op het schrijven van de kernbedrijfslogica.

Bovendien vereenvoudigt het state management bouwblok van Dapr hoe de Node.js-applicatie communiceert met de state store (Amazon ElastiCache). Dapr biedt een consistente API voor het opslaan en ophalen van statusgegevens, waarbij de complexiteit van het beheren en schalen van de onderliggende state store wordt geabstraheerd. Deze abstractie stelt ontwikkelaars in staat om stateful applicaties te bouwen zonder zich zorgen te hoeven maken over de complexiteiten van het beheer van de state store.

De Amazon EKS-cluster host een namespace genaamd dapr-system, die de Dapr control plane-componenten bevat. De dapr-sidecar-injector injecteert automatisch een Dapr-runtime in de pods van Dapr-ingeschakelde microservices.

Stappen voor Service-Oproepen

1. De order generator-service (Python-applicatie) roept de methode van de Node-applicatie aan, /neworder. Dit verzoek wordt verzonden naar de lokale Dapr-sidecar, die wordt uitgevoerd in dezelfde pod als de Python-applicatie. 
2. Dapr lost de doelapplicatie op met behulp van de DNS-provider van de Amazon EKS-cluster en stuurt het verzoek naar de sidecar van de Node-applicatie.
3. De sidecar van de Node-applicatie stuurt vervolgens het verzoek naar de microservice van de Node-applicatie.
4. De Node-applicatie schrijft vervolgens de ontvangen order-ID van de Python-applicatie naar Amazon ElasticCache.
5. De Node-applicatie stuurt de reactie naar zijn lokale Dapr-sidecar.
6. De sidecar van de Node-applicatie stuurt de reactie door naar de Dapr-sidecar van de Python-applicatie. 
7. De Python-applicatie sidecar retourneert de reactie naar de Python-applicatie, die het verzoek had geïnitieerd naar de methode van de Node-applicatie /neworder. 

Implementatiestappen

Maak en bevestig een EKS-cluster

Om een Amazon EKS (Elastic Kubernetes Service) cluster op te zetten, moet je verschillende stappen volgen. Hier is een overzicht van het proces op hoofdniveau:

Vereisten

• Installeer en configureer de AWS CLI
• Installeer eksctl, kubectl en AWS IAM Authenticator

1. Maak een EKS-cluster aan. Gebruik eksctl om een basiscluster aan te maken met een opdracht zoals:

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

2. Configureer kubectl. Werk je kubeconfig bij om verbinding te maken met het nieuwe cluster:

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

3. Controleer het cluster. Controleer of je nodes gereed zijn:

kubectl get nodes

Installeer DAPR op je EKS-cluster

1. Installeer DAPR CLI:

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

2. Controleer de installatie:

dapr -h

3. Installeer DAPR en valideer:

dapr init -k --dev

dapr status -k

De Dapr-componenten statestore en pubsub worden aangemaakt in de standaard namespace. Je kunt dit controleren met de onderstaande opdracht:

dapr components -k

Configureer Amazon ElastiCache als je Dapr StateStore

Maak Amazon ElastiCache aan om de staat voor de microservice op te slaan. In dit voorbeeld gebruiken we ElastiCache serverless, die snel een cache aanmaakt die automatisch schaalt om te voldoen aan de eisen van de toepassingsverkeer zonder servers om te beheren.

Configureer de beveiligingsgroep van de ElastiCache om verbindingen vanaf je EKS-cluster toe te staan. Houd het ter vereenvoudiging in dezelfde VPC als je EKS-cluster. Noteer het cache-eindpunt, dat we nodig hebben voor de volgende stappen.

Een Voorbeeldtoepassing Uitvoeren

1. Clone de Git-repo van de voorbeeldtoepassing:

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

2. Maak redis-state.yaml aan en geef een Amazon ElasticCache-eindpunt op voor 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 

​

Pas de yaml-configuratie voor de state store-component toe met kubectl.

kubectl apply -f redis-state.yaml

3. Zet microservices met de sidecar in.

Voor de microservice node-app, ga naar het /quickstarts/tutorials/hello-kubernetes/deploy/node.yaml bestand en je zult de onderstaande annotaties opmerken. Het vertelt het Dapr-besturingsvlak om een sidecar in te voegen en geeft ook een naam aan de Dapr-toepassing.

annotations:

        dapr.io/enabled: "true"

        dapr.io/app-id: "nodeapp"

        dapr.io/app-port: "3000"

​

Voeg een annotatie service.beta.kubernetes.io/aws-load-balancer-scheme: “internet-facing” toe in node.yaml om een AWS ELB te creëren.

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

​

Deplooi de node-app met kubectl. Navigeer naar de map /quickstarts/tutorials/hello-kubernetes/deploy en voer de onderstaande opdracht uit.

kubectl apply -f node.yaml

Verkrijg de AWS NLB, die verschijnt onder Extern IP, in de uitvoer van de onderstaande opdracht.

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

Navigeer naar de /quickstarts/tutorials/hello-kubernetes map, die het sample.json bestand heeft om de onderstaande stap uit te voeren.

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

Je kunt de uitvoer verifiëren door de /order eindpunt te benaderen met de load balancer in een browser.

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

Je zult de output zien als {"OrderId":"42"}

Vervolgens, implementeer de tweede microservice Python app, die een business logica heeft om elke seconde een nieuw ordernummer te genereren en de methode /neworder van de Node app aan te roepen.

Navigeer naar de map /quickstarts/tutorials/hello-kubernetes/deploy en voer de onderstaande opdracht uit.

kubectl apply -f python.yaml

4. Valideren en testen van je applicatie-implementatie.

Nu we beide microservices hebben geïmplementeerd. De Python app genereert orders en roept /neworder aan zoals blijkt uit de onderstaande logs.

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

We kunnen zien dat de Node app de verzoeken ontvangt en schrijft naar de state store Amazon ElasticCache in ons voorbeeld. 

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

Om te bevestigen of de gegevens zijn opgeslagen in Amazon ElasticCache, benaderen we de endpoint /order hieronder. Het retourneert het laatste ordernummer dat is gegenereerd door de Python app.

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

Je zult een output zien met het meest recente ordernummer als {"OrderId":"370"}. 

Opschonen

Voer de onderstaande opdracht uit om de implementaties van de Node app en Python app samen met het state store component te verwijderen. 

Navigeer naar de map /quickstarts/tutorials/hello-kubernetes/deploy om de onderstaande opdracht uit te voeren.

kubectl delete -f node.yaml

kubectl delete -f python.yaml

Je kunt je EKS-cluster afbouwen met het eksctl-commando en Amazon ElastiCache verwijderen.

Navigeer naar de map met het bestand cluster.yaml dat is gebruikt om het cluster te maken in de eerste stap.

eksctl delete cluster -f cluster.yaml

Conclusie

Dapr en Amazon EKS vormen een krachtige alliantie voor de ontwikkeling van microservices. Dapr vereenvoudigt dwarsdoorsnijdende zorgen, terwijl EKS de Kubernetes-infrastructuur beheert, waardoor ontwikkelaars zich kunnen concentreren op de kernlogica van het bedrijf en de productiviteit kunnen verhogen.

Deze combinatie versnelt de creatie van schaalbare, veerkrachtige en observeerbare applicaties, waarbij de operationele overhead aanzienlijk wordt verminderd. Het is een ideale basis voor uw microservices-reis. Let op toekomstige berichten die de mogelijkheden van Dapr en EKS op het gebied van gedistribueerd traceren en observeerbaarheid verkennen, met diepere inzichten en beste praktijken.