Déployez une application basée sur GRPC sur un cluster Amazon EKS et accédez-y à l'aide d'un Application Load Balancer

Créée par Kirankumar Chandrashekar (AWS) et Huy Nguyen (AWS)

Récapitulatif

Ce modèle décrit comment héberger une application basée sur GRPC sur un cluster Amazon Elastic Kubernetes Service (Amazon EKS) et comment y accéder en toute sécurité via un Application Load Balancer.

gRPC est un framework open source d'appel de procédure à distance (RPC) qui peut s'exécuter dans n'importe quel environnement. Vous pouvez l'utiliser pour les intégrations de microservices et les communications client-serveur. Pour plus d'informations sur gRPC, consultez le billet de blog AWS Application Load Balancer support for end-to-end HTTP/2 and gRPC.

Ce modèle vous montre comment héberger une application basée sur GRPC qui s'exécute sur des pods Kubernetes sur Amazon EKS. Le client gRPC se connecte à un Application Load Balancer via le protocole HTTP/2 avec une connexion cryptée SSL/TLS. L'Application Load Balancer transmet le trafic vers l'application gRPC qui s'exécute sur les pods Amazon EKS. Le nombre de pods gRPC peut être automatiquement redimensionné en fonction du trafic à l'aide du Kubernetes Horizontal Pod Autoscaler. Le groupe cible de l'équilibreur de charge d'application effectue des contrôles de santé sur les nœuds Amazon EKS, évalue si la cible est saine et transmet le trafic uniquement aux nœuds sains.

Conditions préalables et limitations

Prérequis

• Un compte AWS actif.

• Docker, installé et configuré sous Linux, macOS ou Windows.

• Interface de ligne de commande AWS (AWS CLI) version 2, installée et configurée sous Linux, macOS ou Windows.

• eksctl, installé et configuré sous Linux, macOS ou Windows.

• kubectl, installé et configuré pour accéder aux ressources de votre cluster Amazon EKS. Pour plus d'informations, consultez la section Installation ou mise à jour de kubectl dans la documentation Amazon EKS. 

• g RPCurl, installé et configuré.

• Un cluster Amazon EKS nouveau ou existant. Pour plus d'informations, consultez Getting started with Amazon EKS.

• Votre terminal informatique est configuré pour accéder au cluster Amazon EKS. Pour plus d'informations, consultez Configurer votre ordinateur pour communiquer avec votre cluster dans la documentation Amazon EKS.

• AWS Load Balancer Controller, provisionné dans le cluster Amazon EKS.

• Nom d'hôte DNS existant avec un certificat SSL ou SSL/TLS valide. Vous pouvez obtenir un certificat pour votre domaine en utilisant AWS Certificate Manager (ACM) ou en téléchargeant un certificat existant sur ACM. Pour plus d'informations sur ces deux options, consultez les sections Demande d'un certificat public et Importation de certificats dans AWS Certificate Manager dans la documentation ACM.

Architecture

Le schéma suivant montre l'architecture mise en œuvre par ce modèle.

Le schéma suivant montre un flux de travail dans lequel le trafic SSL/TLS est reçu d'un client gRPC qui le décharge vers un Application Load Balancer. Le trafic est transféré en texte clair vers le serveur gRPC car il provient d'un cloud privé virtuel (VPC).

Outils

Services AWS

• L'interface de ligne de commande AWS (AWS CLI) est un outil open source qui vous permet d'interagir avec les services AWS par le biais de commandes dans votre shell de ligne de commande.

• Elastic Load Balancing répartit le trafic applicatif ou réseau entrant sur plusieurs cibles. Par exemple, vous pouvez répartir le trafic entre les instances, les conteneurs et les adresses IP d'Amazon Elastic Compute Cloud (Amazon EC2) dans une ou plusieurs zones de disponibilité.

• Amazon Elastic Container Registry (Amazon ECR) est un service géré de registre d'images de conteneurs sécurisé, évolutif et fiable. 

• Amazon Elastic Kubernetes Service (Amazon EKS) vous aide à exécuter Kubernetes sur AWS sans avoir à installer ou à gérer votre propre plan de contrôle ou vos propres nœuds Kubernetes.  

Outils

• eksctl est un outil CLI simple permettant de créer des clusters sur Amazon EKS.

• kubectl est un utilitaire de ligne de commande permettant d'exécuter des commandes sur des clusters Kubernetes.

• AWS Load Balancer Controller vous aide à gérer les AWS Elastic Load Balancers pour un cluster Kubernetes.

• g RPCurl est un outil en ligne de commande qui vous permet d'interagir avec les services gRPC.

Référentiel de code

Le code de ce modèle est disponible dans le référentiel GitHub grpc-traffic-on-alb-to-eks.

Épopées

Créez et envoyez l'image Docker du serveur gRPC vers Amazon ECR

Tâche	Description	Compétences requises
Créez un référentiel Amazon ECR.	Connectez-vous à l'AWS Management Console, ouvrez la console Amazon ECR, puis créez un référentiel Amazon ECR. Pour plus d'informations, consultez la section Création d'un référentiel dans la documentation Amazon ECR. Assurez-vous d'enregistrer l'URL du référentiel Amazon ECR. Vous pouvez également créer un référentiel Amazon ECR avec l'AWS CLI en exécutant la commande suivante : aws ecr create-repository --repository-name helloworld-grpc	Administrateur du cloud
Développez l'image Docker.	Clonez le référentiel GitHub grpc-traffic-on-alb-to-eks. git clone https://github.com/aws-samples/grpc-traffic-on-alb-to-eks.git Dans le répertoire racine du référentiel, assurez-vous que le Dockerfile existe, puis exécutez la commande suivante pour créer l'image Docker :  docker build -t <amazon_ecr_repository_url>:<Tag> . Important Assurez-vous de <amazon_ecr_repository_url> remplacer par l'URL du référentiel Amazon ECR que vous avez créé précédemment.	DevOps ingénieur
Transférez l'image Docker vers Amazon ECR.	Exécutez la commande suivante pour vous connecter au référentiel 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 Transférez l'image Docker vers le référentiel Amazon ECR en exécutant la commande suivante : docker push <your_aws_account_id>.dkr.ecr.us-east-1.amazonaws.com/helloworld-grpc:1.0 Important Assurez-vous de le remplacer <your_aws_account_id> par votre identifiant de compte AWS.	DevOps ingénieur

Déployez les manifestes Kubernetes sur le cluster Amazon EKS

Tâche	Description	Compétences requises
Modifiez les valeurs du fichier manifeste Kubernetes.	Modifiez le fichier manifeste grpc-sample.yaml Kubernetes dans le dossier Kubernetes du référentiel en fonction de vos besoins. Vous devez modifier les annotations et le nom d'hôte dans la ressource d'entrée. Pour un exemple de ressource d'entrée, consultez la section Informations supplémentaires. Pour plus d'informations sur les annotations d'entrée, consultez la section Annotations d'entrée dans la documentation de Kubernetes. Dans la ressource de déploiement Kubernetes, remplacez la ressource de déploiement par l'identifiant image de ressource uniforme (URI) du référentiel Amazon ECR vers lequel vous avez transféré l'image Docker. Pour un exemple de ressource de déploiement, consultez la section Informations supplémentaires.	DevOps ingénieur
Déployez le fichier manifeste Kubernetes.	Déployez le grpc-sample.yaml fichier sur le cluster Amazon EKS en exécutant la kubectl commande suivante :  kubectl apply -f ./kubernetes/grpc-sample.yaml	DevOps ingénieur

Créez l'enregistrement DNS pour le FQDN de l'équilibreur de charge d'application

Tâche	Description	Compétences requises
Enregistrez le nom de domaine complet de l'Application Load Balancer.	Exécutez la kubectl commande suivante pour décrire la ressource d'entrée Kubernetes qui gère l'Application Load Balancer : kubectl get ingress -n grpcserver Un exemple de sortie est fourni dans la section Informations supplémentaires. Dans le résultat, le HOSTS champ affiche le nom d'hôte DNS pour lequel les certificats SSL ont été créés. Enregistrez le nom de domaine complet (FQDN) de l'équilibreur de charge d'application Address dans le champ de sortie.  Créez un enregistrement DNS qui pointe vers le FQDN de l'équilibreur de charge d'application. Si votre fournisseur DNS est Amazon Route 53, vous pouvez créer un enregistrement d'alias qui pointe vers le nom de domaine complet de l'équilibreur de charge d'application. Pour plus d'informations sur cette option, consultez Choisir entre des enregistrements alias et des enregistrements non alias dans la documentation de Route 53.	DevOps ingénieur

Tester la solution

Tâche	Description	Compétences requises
Testez le serveur gRPC.	Utilisez g RPCurl pour tester le point de terminaison en exécutant la commande suivante : grpcurl grpc.example.com:443 list grpc.reflection.v1alpha.ServerReflection helloworld.helloworld Note grpc.example.comRemplacez-le par votre nom DNS.	DevOps ingénieur
Testez le serveur gRPC à l'aide d'un client gRPC.	Dans l'helloworld_client_ssl.pyexemple de client gRPC, remplacez le nom d'hôte de par le nom grpc.example.com d'hôte utilisé pour le serveur gRPC.   L'exemple de code suivant montre la réponse du serveur gRPC à la demande du 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 Cela montre que le client peut communiquer avec le serveur et que la connexion est réussie.	DevOps ingénieur

Nettoyage

Tâche	Description	Compétences requises
Supprimez l'enregistrement DNS.	Supprimez l'enregistrement DNS qui pointe vers le FQDN de l'équilibreur de charge d'application que vous avez créé précédemment.	Administrateur du cloud
Retirez l'équilibreur de charge.	Sur la EC2 console Amazon, choisissez Load Balancers, puis supprimez l'équilibreur de charge créé par le contrôleur Kubernetes pour votre ressource d'entrée.	Administrateur du cloud
Supprimez le cluster Amazon EKS.	Supprimez le cluster Amazon EKS en utilisant eksctl : eksctl delete cluster -f ./eks.yaml	AWS DevOps

Ressources connexes

• Répartition de charge réseau sur Amazon EKS

• Groupes cibles pour vos équilibreurs de charge d'applications

Informations supplémentaires

Exemple de ressource d'entrée :

---
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>
  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

Exemple de ressource de déploiement :

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

Exemple de sortie :

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