Implementa un'applicazione basata su gRPC su un cluster Amazon EKS e accedi ad essa con un Application Load Balancer

Creato da Kirankumar Chandrashekar (AWS) e Huy Nguyen (AWS)

Archivio del grpc-traffic-on-alb codice: -to-eks	Ambiente: PoC o pilota	Tecnologie: contenitori e microservizi; Distribuzione di contenuti; App Web e mobili
Carico di lavoro: tutti gli altri carichi di lavoro	Servizi AWS: Amazon EKS; Elastic Load Balancing (ELB)

Riepilogo

Questo modello descrive come ospitare un'applicazione basata su gRPC su un cluster Amazon Elastic Kubernetes Service (Amazon EKS) e accedervi in modo sicuro tramite un Application Load Balancer.

gRPC è un framework RPC (Remote Procedure Call) open source che può essere eseguito in qualsiasi ambiente. È possibile utilizzarlo per integrazioni di microservizi e comunicazioni client-server. Per ulteriori informazioni su gRPC, consulta il post sul blog di AWS Application Load Balancer support per end-to-end HTTP/2 e gRPC.

Questo modello mostra come ospitare un'applicazione basata su gRPC che viene eseguita su pod Kubernetes su Amazon EKS. Il client gRPC si connette a un Application Load Balancer tramite il protocollo HTTP/2 con una connessione crittografata SSL/TLS. L'Application Load Balancer inoltra il traffico all'applicazione gRPC in esecuzione sui pod Amazon EKS. Il numero di pod gRPC può essere ridimensionato automaticamente in base al traffico utilizzando Kubernetes Horizontal Pod Autoscaler. Il gruppo target di Application Load Balancer esegue controlli di integrità sui nodi Amazon EKS, valuta se il target è integro e inoltra il traffico solo ai nodi integri.

Prerequisiti e limitazioni

Prerequisiti

• Un account AWS attivo.

• Docker, installato e configurato su Linux, macOS o Windows.

• AWS Command Line Interface (AWS CLI) versione 2, installata e configurata su Linux, macOS o Windows.

• eksctl, installato e configurato su Linux, macOS o Windows.

• kubectl, installato e configurato per accedere alle risorse sul tuo cluster Amazon EKS. Per ulteriori informazioni, consulta Installazione o aggiornamento di kubectl nella documentazione di Amazon EKS. 

• grpCurl, installato e configurato.

• Un cluster Amazon EKS nuovo o esistente. Per ulteriori informazioni, consulta Guida introduttiva ad Amazon EKS.

• Il terminale del computer è configurato per accedere al cluster Amazon EKS. Per ulteriori informazioni, consulta Configurare il computer per comunicare con il cluster nella documentazione di Amazon EKS.

• AWS Load Balancer Controller, fornito nel cluster Amazon EKS.

• Un nome host DNS esistente con un certificato SSL o SSL/TLS valido. Puoi ottenere un certificato per il tuo dominio utilizzando AWS Certificate Manager (ACM) o caricando un certificato esistente su ACM. Per ulteriori informazioni su queste due opzioni, consulta Richiesta di un certificato pubblico e Importazione di certificati in AWS Certificate Manager nella documentazione ACM.

Architettura

Il diagramma seguente mostra l'architettura implementata da questo modello.

Il diagramma seguente mostra un flusso di lavoro in cui il traffico SSL/TLS viene ricevuto da un client gRPC che esegue l'offload su un Application Load Balancer. Il traffico viene inoltrato in testo semplice al server gRPC perché proviene da un cloud privato virtuale (VPC).

Strumenti

Servizi AWS

• AWS Command Line Interface (AWS CLI) è uno strumento open source che ti aiuta a interagire con i servizi AWS tramite comandi nella shell della riga di comando.

• Elastic Load Balancing distribuisce il traffico di applicazioni o di rete in entrata su più destinazioni. Ad esempio, puoi distribuire il traffico tra istanze Amazon Elastic Compute Cloud (Amazon EC2), contenitori e indirizzi IP in una o più zone di disponibilità.

• Amazon Elastic Container Registry (Amazon ECR) è un servizio di registro di immagini di container gestito sicuro, scalabile e affidabile. 

• Amazon Elastic Kubernetes Service (Amazon EKS) ti aiuta a eseguire Kubernetes su AWS senza dover installare o gestire il tuo piano di controllo o i tuoi nodi Kubernetes.  

Strumenti

• eksctl è un semplice strumento CLI per la creazione di cluster su Amazon EKS.

• kubectl è un'utilità da riga di comando per eseguire comandi su cluster Kubernetes.

• AWS Load Balancer Controller ti aiuta a gestire AWS Elastic Load Balancers per un cluster Kubernetes.

• grpCURL è uno strumento da riga di comando che consente di interagire con i servizi gRPC.

Deposito di codice

Il codice per questo pattern è disponibile nel repository GitHub grpc-traffic-on-alb-to-eks.

Epiche

Crea e invia l'immagine Docker del server gRPC su Amazon ECR

Attività	Descrizione	Competenze richieste
Crea un repository Amazon ECR.	Accedi alla Console di gestione AWS, apri la console Amazon ECR e crea un repository Amazon ECR. Per ulteriori informazioni, consulta Creazione di un repository nella documentazione di Amazon ECR. Assicurati di registrare l'URL del repository Amazon ECR. Puoi anche creare un repository Amazon ECR con AWS CLI eseguendo il seguente comando: aws ecr create-repository --repository-name helloworld-grpc	Amministratore cloud
Creazione dell'immagine Docker.	Clona il repository GitHub grpc-traffic-on-alb-to-eks. git clone https://github.com/aws-samples/grpc-traffic-on-alb-to-eks.git Dalla directory principale del repository, assicurati che il Dockerfile esista, quindi esegui il seguente comando per creare l'immagine Docker:  docker build -t <amazon_ecr_repository_url>:<Tag> . Importante: assicurati di sostituirlo <amazon_ecr_repository_url> con l'URL del repository Amazon ECR creato in precedenza.	DevOps ingegnere
Invia l'immagine Docker ad Amazon ECR.	Esegui il seguente comando per accedere al repository Amazon ECR: aws ecr get-login-password --region us-east-1 --no-cli-auto-prompt | docker login --username AWS --password-stdin <your_aws_account_id>.dkr.ecr.us-east-1.amazonaws.com Invia l'immagine Docker al repository Amazon ECR eseguendo il seguente comando: docker push <your_aws_account_id>.dkr.ecr.us-east-1.amazonaws.com/helloworld-grpc:1.0 Importante: assicurati di sostituirlo <your_aws_account_id> con l'ID del tuo account AWS.	DevOps ingegnere

Implementa i manifest Kubernetes nel cluster Amazon EKS

Attività	Descrizione	Competenze richieste
Modifica i valori nel file manifest di Kubernetes.	Modifica il file manifest grpc-sample.yaml Kubernetes nella cartella Kubernetes del repository in base alle tue esigenze. È necessario modificare le annotazioni e il nome host nella risorsa di ingresso. Per un esempio di risorsa in ingresso, consultate la sezione Informazioni aggiuntive. Per ulteriori informazioni sulle annotazioni in ingresso, consulta le annotazioni in ingresso nella documentazione di Kubernetes. Nella risorsa di distribuzione Kubernetes, modifica le risorse di distribuzione con l'URI (Uniform Resource Identifier) per il repository Amazon ECR in cui hai inviato l'immagine Docker. image Per un esempio di risorsa di distribuzione, consulta la sezione Informazioni aggiuntive.	DevOps ingegnere
Distribuisci il file manifest di Kubernetes.	Distribuisci il grpc-sample.yaml file nel cluster Amazon EKS eseguendo il seguente kubectl comando:  kubectl apply -f ./kubernetes/grpc-sample.yaml	DevOps ingegnere

Crea il record DNS per l'FQDN di Application Load Balancer

Attività	Descrizione	Competenze richieste
Registra il nome di dominio completo per l'Application Load Balancer.	Esegui il kubectl comando seguente per descrivere la risorsa di ingresso Kubernetes che gestisce l'Application Load Balancer: kubectl get ingress -n grpcserver L'output di esempio è fornito nella sezione Informazioni aggiuntive. Nell'output, il HOSTS campo mostra il nome host DNS per cui sono stati creati i certificati SSL. Registra il nome di dominio completo (FQDN) dell'Application Load Balancer dal campo dell'Addressoutput.  Crea un record DNS che punti all'FQDN di Application Load Balancer. Se il tuo provider DNS è Amazon Route 53, puoi creare un record di alias che punti al nome di dominio completo di Application Load Balancer. Per ulteriori informazioni su questa opzione, consulta Scelta tra record alias e non alias nella documentazione di Route 53.	DevOps ingegnere

Test della soluzione

Attività	Descrizione	Competenze richieste
Prova il server gRPC.	Usa grpCurl per testare l'endpoint eseguendo il seguente comando: grpcurl grpc.example.com:443 list grpc.reflection.v1alpha.ServerReflection helloworld.helloworld Nota: sostituiscilo grpc.example.com con il tuo nome DNS.	DevOps ingegnere
Prova il server gRPC utilizzando un client gRPC.	Nel client gRPC di helloworld_client_ssl.py esempio, sostituisci il nome host di grpc.example.com con il nome host utilizzato per il server gRPC.   Il seguente esempio di codice mostra la risposta del server gRPC alla richiesta del client: python ./app/helloworld_client_ssl.py message: "Hello to gRPC server from Client" message: "Thanks for talking to gRPC server!! Welcome to hello world. Received message is \"Hello to gRPC server from Client\"" received: true Ciò dimostra che il client può parlare con il server e che la connessione è riuscita.	DevOps ingegnere

Eliminazione

Attività	Descrizione	Competenze richieste
Rimuovi il record DNS.	Rimuovi il record DNS che rimanda al nome di dominio completo di Application Load Balancer creato in precedenza.	Amministratore cloud
Rimuovi il sistema di bilanciamento del carico.	Sulla console Amazon EC2, scegli Load Balancers, quindi rimuovi il load balancer creato dal controller Kubernetes per la tua risorsa in ingresso.	Amministratore cloud
Elimina il cluster Amazon EKS.	Elimina il cluster Amazon EKS utilizzandoeksctl: eksctl delete cluster -f ./eks.yaml	AWS DevOps

Risorse correlate

• Bilanciamento del carico di rete su Amazon EKS

• Gruppi target per i tuoi Application Load Balancer

Informazioni aggiuntive

Esempio di risorsa di ingresso:

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  annotations:
    alb.ingress.kubernetes.io/healthcheck-protocol: HTTP
    alb.ingress.kubernetes.io/ssl-redirect: "443"
    alb.ingress.kubernetes.io/backend-protocol-version: "GRPC"
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTP": 80}, {"HTTPS":443}]'
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/target-type: ip
    alb.ingress.kubernetes.io/certificate-arn: arn:aws:acm:<AWS-Region>:<AccountId>:certificate/<certificate_ID>
    alb.ingress.kubernetes.io/healthcheck-protocol: HTTP
  labels:
    app: grpcserver
    environment: dev
  name: grpcserver
  namespace: grpcserver
spec:
  ingressClassName: alb
  rules:
  - host: grpc.example.com # <----- replace this as per your host name for which the SSL certtficate is available in ACM
    http:
      paths:
      - backend:
          service:
            name: grpcserver
            port:
              number: 9000
        path: /
        pathType: Prefix

Esempio di risorsa di implementazione:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: grpcserver
  namespace: grpcserver
spec:
  selector:
    matchLabels:
      app: grpcserver
  replicas: 1
  template:
    metadata:
      labels:
        app: grpcserver
    spec:
      containers:
      - name: grpc-demo
        image: <your_aws_account_id>.dkr.ecr.us-east-1.amazonaws.com/helloworld-grpc:1.0   #<------- Change to the URI that the Docker image is pushed to
        imagePullPolicy: Always
        ports:
        - name: grpc-api
          containerPort: 9000
        env:
        - name: POD_IP
          valueFrom:
            fieldRef:
              fieldPath: status.podIP
      restartPolicy: Always

Output di esempio:

NAME             CLASS           HOSTS                          Address                PORTS          AGE
 grpcserver      <none>      <DNS-HostName>                  <ELB-address>              80            27d