Déploiement et débogage de clusters Amazon EKS

Créée par Svenja Raether (AWS) et Mathew George (AWS)

Environnement : PoC ou pilote	Technologies : conteneurs et microservices ; infrastructure ; modernisation ; sans serveur ; cloud native	Charge de travail : toutes les autres charges de travail
Services AWS : Amazon EKS ; AWS Fargate

Récapitulatif

Les conteneurs sont en train de devenir un élément essentiel du développement d'applications cloud natives. Kubernetes fournit un moyen efficace de gérer et d'orchestrer les conteneurs. Amazon Elastic Kubernetes Service (Amazon EKS) est un service entièrement géré et certifié conforme à Kubernetes destiné à la création, à la sécurisation, à l'exploitation et à la maintenance de clusters Kubernetes sur Amazon Web Services (AWS). Il prend en charge l'exécution de modules sur AWS Fargate afin de fournir une capacité de calcul adaptée à la demande.

Il est important que les développeurs et les administrateurs connaissent les options de débogage lorsqu'ils exécutent des charges de travail conteneurisées. Ce modèle vous guide dans le déploiement et le débogage de conteneurs sur Amazon EKS avec AWS Fargate. Cela inclut la création, le déploiement, l'accès, le débogage et le nettoyage des charges de travail Amazon EKS.

Conditions préalables et limitations

Prérequis

• Un compte AWS actif

• Rôle AWS Identity and Access Management (IAM) configuré avec des autorisations suffisantes pour créer et interagir avec Amazon EKS, les rôles IAM et les rôles liés à un service

• Interface de ligne de commande AWS (AWS CLI) (AWS CLI) installée sur la machine locale

• eksctl

• kubectl

• Casque

Limites

• Ce modèle fournit aux développeurs des pratiques de débogage utiles pour les environnements de développement. Il n'indique pas les meilleures pratiques pour les environnements de production.

• Si vous utilisez Windows, utilisez les commandes spécifiques à votre système d'exploitation pour définir les variables d'environnement.

Versions du produit utilisées

• Version 2 de l'interface de ligne de commande AWS

• version kubectl avec une différence de version mineure par rapport au plan de contrôle Amazon EKS que vous utilisez

• dernière version de eksctl

• Casque v3

Architecture

Pile technologique

• Application Load Balancer

• Amazon EKS

• AWS Fargate

Architecture cible

Toutes les ressources présentées dans le diagramme sont approvisionnées à l'aide eksctl de kubectl commandes émises par une machine locale. Les clusters privés doivent être exécutés à partir d'une instance située dans le VPC privé.

L'architecture cible consiste en un cluster EKS utilisant le type de lancement Fargate. Cela fournit une capacité de calcul adaptée à la demande sans qu'il soit nécessaire de spécifier les types de serveurs. Le cluster EKS possède un plan de contrôle, qui est utilisé pour gérer les nœuds du cluster et les charges de travail. Les pods sont approvisionnés dans des sous-réseaux VPC privés couvrant plusieurs zones de disponibilité. La galerie publique Amazon ECR est référencée pour récupérer et déployer une image de serveur Web NGINX sur les pods du cluster.

Le schéma montre comment accéder au plan de contrôle Amazon EKS à l'aide de kubectl commandes et comment accéder à l'application à l'aide de l'Application Load Balancer.

.

1. Une machine locale en dehors du cloud AWS envoie des commandes au plan de contrôle Kubernetes à l'intérieur d'un VPC géré par Amazon EKS.

2. Amazon EKS planifie les pods en fonction des sélecteurs du profil Fargate.

3. La machine locale ouvre l'URL de l'Application Load Balancer dans le navigateur.

4. L'Application Load Balancer divise le trafic entre les pods Kubernetes des nœuds du cluster Fargate déployés dans des sous-réseaux privés couvrant plusieurs zones de disponibilité.

Outils

Services AWS

• 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. Ce modèle utilise également l'outil de ligne de commande eksctl pour travailler avec les clusters Kubernetes sur Amazon EKS.

• AWS Fargate vous permet d'exécuter des conteneurs sans avoir à gérer de serveurs ou d'instances Amazon Elastic Compute Cloud (Amazon EC2). Il est utilisé conjointement avec Amazon Elastic Container Service (Amazon ECS).

• Elastic Load Balancing (ELB) 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 Amazon Elastic Compute Cloud (Amazon EC2) dans une ou plusieurs zones de disponibilité. Ce modèle utilise le composant de contrôle AWS Load Balancer Controller pour créer l'Application Load Balancer lorsqu'une entrée Kubernetes est provisionnée. L'Application Load Balancer répartit le trafic entrant entre plusieurs cibles.

Autres outils

• Helm est un gestionnaire de paquets open source pour Kubernetes. Dans ce modèle, Helm est utilisé pour installer le contrôleur AWS Load Balancer.

• Kubernetes est un système open source permettant d'automatiser le déploiement, le dimensionnement et la gestion des applications conteneurisées.

• NGINX est un serveur Web et un serveur proxy inverse à hautes performances.

Épopées

Création d'un cluster EKS

Tâche	Description	Compétences requises
Créez les fichiers.	À l'aide du code de la section Informations supplémentaires, créez les fichiers suivants : clusterconfig-fargate.yaml nginx-deployment.yaml nginx-service.yaml nginx-ingress.yaml index.html	Développeur d'applications, administrateur AWS, AWS DevOps
Définissez les variables d'environnement.	Remarque : Si une commande échoue en raison de tâches inachevées précédentes, attendez quelques secondes, puis réexécutez la commande. Ce modèle utilise la région AWS et le nom du cluster définis dans le fichierclusterconfig-fargate.yaml. Définissez les mêmes valeurs que les variables d'environnement pour les référencer dans d'autres commandes. export AWS_REGION="us-east-1" export CLUSTER_NAME="my-fargate"	Développeur d'applications, AWS DevOps, administrateur système AWS
Créez un cluster EKS.	Pour créer un cluster EKS qui utilise les spécifications du clusterconfig-fargate.yaml fichier, exécutez la commande suivante. eksctl create cluster -f clusterconfig-fargate.yaml Le fichier contient leClusterConfig, qui fournit un nouveau cluster EKS nommé my-fargate-cluster dans la us-east-1 région et un profil Fargate par défaut (). fp-default Le profil Fargate par défaut est configuré avec deux sélecteurs default (et). kube-system	Développeur d'applications, AWS DevOps, administrateur AWS
Vérifiez le cluster créé.	Pour vérifier le cluster créé, exécutez la commande suivante. eksctl get cluster --output yaml Le résultat doit être le suivant. - Name: my-fargate Owned: "True" Region: us-east-1 Vérifiez le profil Fargate créé à l'aide du. CLUSTER_NAME eksctl get fargateprofile --cluster $CLUSTER_NAME --output yaml Cette commande affiche des informations sur les ressources. Vous pouvez utiliser ces informations pour vérifier le cluster créé. Le résultat doit être le suivant. - name: fp-default podExecutionRoleARN: arn:aws:iam::<YOUR-ACCOUNT-ID>:role/eksctl-my-fargate-cluster-FargatePodExecutionRole-xxx selectors: - namespace: default - namespace: kube-system status: ACTIVE subnets: - subnet-aaa - subnet-bbb - subnet-ccc	Développeur d'applications, AWS DevOps, administrateur système AWS

Déployer un conteneur

Tâche	Description	Compétences requises
Déployez le serveur Web NGINX.	Pour appliquer le déploiement du serveur Web NGINX sur le cluster, exécutez la commande suivante. kubectl apply -f ./nginx-deployment.yaml Le résultat doit être le suivant. deployment.apps/nginx-deployment created Le déploiement inclut trois répliques de l'image NGINX extraite de la galerie publique Amazon ECR. L'image est déployée dans l'espace de noms par défaut et exposée sur le port 80 des pods en cours d'exécution.	Développeur d'applications, AWS DevOps, administrateur système AWS
Vérifiez le déploiement et les modules.	(Facultatif) Vérifiez le déploiement. Vous pouvez vérifier l'état de votre déploiement à l'aide de la commande suivante. kubectl get deployment Le résultat doit être le suivant. NAME READY UP-TO-DATE AVAILABLE AGE nginx-deployment 3/3 3 3 7m14s Un pod est un objet déployable dans Kubernetes contenant un ou plusieurs conteneurs. Pour répertorier tous les pods, exécutez la commande suivante.  kubectl get pods Le résultat doit être le suivant. NAME READY STATUS RESTARTS AGE nginx-deployment-xxxx-aaa 1/1 Running 0 94s nginx-deployment-xxxx-bbb 1/1 Running 0 94s nginx-deployment-xxxx-ccc 1/1 Running 0 94s	Développeur d'applications, AWS DevOps, administrateur AWS
Élargissez le déploiement.	Pour faire passer le déploiement des trois répliques spécifiées dans deployment.yaml à quatre répliques, utilisez la commande suivante.  kubectl scale deployment nginx-deployment --replicas 4 Le résultat doit être le suivant. deployment.apps/nginx-deployment scaled	Développeur d'applications, AWS DevOps, administrateur système AWS

Déployer un contrôleur AWS Load Balancer

Tâche	Description	Compétences requises
Définissez les variables d'environnement.	Décrivez la CloudFormation pile du cluster pour récupérer des informations sur son VPC. aws cloudformation describe-stacks --stack-name eksctl-$CLUSTER_NAME-cluster --query "Stacks[0].Outputs[?OutputKey==\`VPC\`].OutputValue" Le résultat doit être le suivant. [ "vpc-<YOUR-VPC-ID>" ] Copiez l'ID VPC et exportez-le en tant que variable d'environnement. export VPC_ID="vpc-<YOUR-VPC-ID>"	Développeur d'applications, AWS DevOps, administrateur système AWS
Configurez IAM pour le compte de service de cluster.	Utilisez les extraits AWS_REGION et CLUSTER_NAME extraits de l'épopée précédente pour créer un fournisseur IAM Open ID Connect pour le cluster. eksctl utils associate-iam-oidc-provider \ --region $AWS_REGION \ --cluster $CLUSTER_NAME \ --approve	Développeur d'applications, AWS DevOps, administrateur système AWS
Téléchargez et créez la politique IAM.	Téléchargez la politique IAM pour le contrôleur AWS Load Balancer qui lui permet de passer des appels aux API AWS en votre nom. curl -o iam-policy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/main/docs/install/iam_policy.json Créez la politique dans votre compte AWS à l'aide de l'interface de ligne de commande AWS. aws iam create-policy \ --policy-name AWSLoadBalancerControllerIAMPolicy \ --policy-document file://iam-policy.json Le résultat suivant doit s'afficher. { "Policy": { "PolicyName": "AWSLoadBalancerControllerIAMPolicy", "PolicyId": "<YOUR_POLICY_ID>", "Arn": "arn:aws:iam::<YOUR-ACCOUNT-ID>:policy/AWSLoadBalancerControllerIAMPolicy", "Path": "/", "DefaultVersionId": "v1", "AttachmentCount": 0, "PermissionsBoundaryUsageCount": 0, "IsAttachable": true, "CreateDate": "<YOUR-DATE>", "UpdateDate": "<YOUR-DATE>" } } Enregistrez le nom de ressource Amazon (ARN) de la politique sous$POLICY_ARN. export POLICY_ARN=”arn:aws:iam::<YOUR-ACCOUNT-ID>:policy/AWSLoadBalancerControllerIAMPolicy”	Développeur d'applications, AWS DevOps, administrateur système AWS
Créez un compte de service IAM.	Créez un compte de service IAM nommé aws-load-balancer-controller dans l'espace de kube-system noms. Utilisez le CLUSTER_NAMEAWS_REGION, et POLICY_ARN que vous avez configuré précédemment. eksctl create iamserviceaccount \ --cluster=$CLUSTER_NAME \ --region=$AWS_REGION \ --attach-policy-arn=$POLICY_ARN \ --namespace=kube-system \ --name=aws-load-balancer-controller \ --override-existing-serviceaccounts \ --approve Vérifiez la création. eksctl get iamserviceaccount \ --cluster $CLUSTER_NAME \ --name aws-load-balancer-controller \ --namespace kube-system \ --output yaml Le résultat doit être le suivant. - metadata: name: aws-load-balancer-controller namespace: kube-system status: roleARN: arn:aws:iam::<YOUR-ACCOUNT-ID>:role/eksctl-my-fargate-addon-iamserviceaccount-ku-Role1-<YOUR-ROLE-ID> wellKnownPolicies: autoScaler: false awsLoadBalancerController: false certManager: false ebsCSIController: false efsCSIController: false externalDNS: false imageBuilder: false	Développeur d'applications, AWS DevOps, administrateur système AWS
Installez le contrôleur AWS Load Balancer.	Mettez à jour le référentiel Helm. helm repo update Ajoutez le référentiel de graphiques Amazon EKS au référentiel Helm.  helm repo add eks https://aws.github.io/eks-charts Appliquez les définitions de ressources personnalisées (CRD) Kubernetes utilisées par le AWS Load Balancer Controller eks-chart en arrière-plan. kubectl apply -k "github.com/aws/eks-charts/stable/aws-load-balancer-controller//crds?ref=master" Le résultat doit être le suivant. customresourcedefinition.apiextensions.k8s.io/ingressclassparams.elbv2.k8s.aws created customresourcedefinition.apiextensions.k8s.io/targetgroupbindings.elbv2.k8s.aws created Installez le graphique Helm en utilisant les variables d'environnement que vous avez définies précédemment. helm install aws-load-balancer-controller eks/aws-load-balancer-controller \ --set clusterName=$CLUSTER_NAME \ --set serviceAccount.create=false \ --set region=$AWS_REGION \ --set vpcId=$VPC_ID \ --set serviceAccount.name=aws-load-balancer-controller \ -n kube-system Le résultat doit être le suivant. NAME: aws-load-balancer-controller LAST DEPLOYED: <YOUR-DATE> NAMESPACE: kube-system STATUS: deployed REVISION: 1 TEST SUITE: None NOTES: AWS Load Balancer controller installed!	Développeur d'applications, AWS DevOps, administrateur système AWS
Créez un service NGINX.	Créez un service pour exposer les pods NGINX à l'aide du nginx-service.yaml fichier. kubectl apply -f nginx-service.yaml Le résultat doit être le suivant. service/nginx-service created	Développeur d'applications, AWS DevOps, administrateur système AWS
Créez la ressource d'entrée Kubernetes.	Créez un service pour exposer l'entrée NGINX de Kubernetes à l'aide du fichier. nginx-ingress.yaml kubectl apply -f nginx-ingress.yaml Le résultat doit être le suivant. ingress.networking.k8s.io/nginx-ingress created	Développeur d'applications, AWS DevOps, administrateur système AWS
Obtenez l'URL de l'équilibreur de charge.	Pour récupérer les informations d'entrée, utilisez la commande suivante. kubectl get ingress nginx-ingress Le résultat doit être le suivant. NAME CLASS HOSTS ADDRESS PORTS AGE nginx-ingress <none> * k8s-default-nginxing-xxx.us-east-1.elb.amazonaws.com 80 80s Copiez ADDRESS (par exemplek8s-default-nginxing-xxx.us-east-1.elb.amazonaws.com) le fichier de sortie et collez-le dans votre navigateur pour accéder au index.html fichier.	Développeur d'applications, AWS DevOps, administrateur système AWS

Déboguer les conteneurs en cours d'exécution

Tâche	Description	Compétences requises
Sélectionnez un module.	Répertoriez tous les modules et copiez le nom du module souhaité.  kubectl get pods Le résultat doit être le suivant. NAME READY STATUS RESTARTS AGE nginx-deployment-xxxx-aaa 1/1 Running 0 55m nginx-deployment-xxxx-bbb 1/1 Running 0 55m nginx-deployment-xxxx-ccc 1/1 Running 0 55m nginx-deployment-xxxx-ddd 1/1 Running 0 42m Cette commande répertorie les modules existants ainsi que des informations supplémentaires. Si vous êtes intéressé par un module spécifique, saisissez le nom du module qui vous intéresse pour la POD_NAME variable ou définissez-le comme variable d'environnement. Sinon, omettez ce paramètre pour rechercher toutes les ressources. export POD_NAME="nginx-deployment-<YOUR-POD-NAME>"	Développeur d'applications, AWS DevOps, administrateur système AWS
Accédez aux journaux.	Récupérez les journaux du module que vous souhaitez déboguer. kubectl logs $POD_NAME	Développeur d'applications, administrateur système AWS, AWS DevOps
Transférez le port NGINX.	Utilisez le transfert de port pour mapper le port du pod permettant d'accéder au serveur Web NGINX à un port de votre machine locale. kubectl port-forward deployment/nginx-deployment 8080:80 Dans votre navigateur, ouvrez l'URL suivante. http://localhost:8080 La port-forward commande permet d'accéder au index.html fichier sans le rendre accessible au public via un équilibreur de charge. Ceci est utile pour accéder à l'application en cours d'exécution lors de son débogage. Vous pouvez arrêter le transfert de port en appuyant sur la commande clavier Ctrl+C.	Développeur d'applications, AWS DevOps, administrateur système AWS
Exécutez des commandes dans le module.	Pour consulter le index.html fichier en cours, utilisez la commande suivante.  kubectl exec $POD_NAME -- cat /usr/share/nginx/html/index.html Vous pouvez utiliser la exec commande pour émettre n'importe quelle commande directement dans le module. Cela est utile pour le débogage des applications en cours d'exécution.	Développeur d'applications, AWS DevOps, administrateur système AWS
Copiez des fichiers dans un module.	Supprimez le index.html fichier par défaut de ce module. kubectl exec $POD_NAME -- rm /usr/share/nginx/html/index.html Téléchargez le fichier index.html local personnalisé dans le module. kubectl cp index.html $POD_NAME:/usr/share/nginx/html/ Vous pouvez utiliser la cp commande pour modifier ou ajouter des fichiers directement dans n'importe quel module.	Développeur d'applications, AWS DevOps, administrateur système AWS
Utilisez le transfert de port pour afficher la modification.	Utilisez le transfert de port pour vérifier les modifications que vous avez apportées à ce module. kubectl port-forward pod/$POD_NAME 8080:80 Ouvrez l'URL suivante dans votre navigateur. http://localhost:8080 Les modifications apportées au index.html fichier doivent être visibles dans le navigateur.	Développeur d'applications, AWS DevOps, administrateur système AWS

Supprimer des ressources

Tâche	Description	Compétences requises
Supprimez l'équilibreur de charge.	Supprimez l'entrée. kubectl delete ingress/nginx-ingress Le résultat doit être le suivant. ingress.networking.k8s.io "nginx-ingress" deleted Supprimez le service. kubectl delete service/nginx-service Le résultat doit être le suivant. service "nginx-service" deleted Supprimez le contrôleur d'équilibrage de charge. helm delete aws-load-balancer-controller -n kube-system Le résultat doit être le suivant. release "aws-load-balancer-controller" uninstalled Supprimez le compte de service. eksctl delete iamserviceaccount --cluster $CLUSTER_NAME --namespace kube-system --name aws-load-balancer-controller	Développeur d'applications, AWS DevOps, administrateur système AWS
Supprimez le déploiement.	Pour supprimer les ressources de déploiement, utilisez la commande suivante. kubectl delete deploy/nginx-deployment Le résultat doit être le suivant. deployment.apps "nginx-deployment" deleted	Développeur d'applications, AWS DevOps, administrateur système AWS
Supprimez le cluster.	Supprimez le cluster EKS à l'aide de la commande suivante, où se my-fargate trouve le nom du cluster. eksctl delete cluster --name $CLUSTER_NAME Cette commande supprime l'ensemble du cluster, y compris toutes les ressources associées.	Développeur d'applications, AWS DevOps, administrateur système AWS
Supprimez la politique IAM.	Supprimez la politique créée précédemment à l'aide de l'interface de ligne de commande AWS. aws iam delete-policy --policy-arn $POLICY_ARN	Développeur d'applications, administrateur AWS, AWS DevOps

Résolution des problèmes

Problème

Solution

Vous recevez un message d'erreur lors de la création du cluster indiquant que la capacité de votre zone de disponibilité ciblée n'est pas suffisante pour prendre en charge le cluster. Un message similaire au suivant devrait s'afficher. Cannot create cluster 'my-fargate' because us-east-1e, the targeted availability zone, does not currently have sufficient capacity to support the cluster. Retry and choose from these availability zones: us-east-1a, us-east-1b, us-east-1c, us-east-1d, us-east-1f

Créez à nouveau le cluster en utilisant les zones de disponibilité recommandées dans le message d'erreur. Spécifiez une liste de zones de disponibilité dans la dernière ligne de votre clusterconfig-fargate.yaml fichier (par exemple,availabilityZones: ["us-east-1a", "us-east-1b", "us-east-1c"]).

Ressources connexes

• Documentation Amazon EKS

• Équilibrage de charge des applications sur Amazon EKS

• Guides des meilleures pratiques EKS

• Documentation du contrôleur AWS Load Balancer

• documentation eksctl

• Image NGINX de la galerie publique Amazon ECR

• Documentation du casque

• Déboguer les pods en cours d'exécution (documentation Kubernetes)

• Atelier Amazon EKS

• Erreurs de création de cluster EKS

Informations supplémentaires

clusterconfig-fargate.yaml

apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: my-fargate
  region: us-east-1

fargateProfiles:
  - name: fp-default
    selectors:
      - namespace: default
      - namespace: kube-system

nginx-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: "nginx-deployment"
  namespace: "default"
spec:
  replicas: 3
  selector:
    matchLabels:
      app: "nginx"
  template:
    metadata:
      labels:
        app: "nginx"
    spec:
      containers:
      - name: nginx
        image: public.ecr.aws/nginx/nginx:latest  
        ports:
        - containerPort: 80

nginx-service.yaml

apiVersion: v1
kind: Service
metadata:
  annotations:
    alb.ingress.kubernetes.io/target-type: ip
  name: "nginx-service"
  namespace: "default"
spec:
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  type: NodePort
  selector:
    app: "nginx"

nginx-ingress.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: "default"
  name:  "nginx-ingress"
  annotations:
    kubernetes.io/ingress.class: alb
    alb.ingress.kubernetes.io/scheme: internet-facing
spec:
  rules:
    - http:
        paths:
        - path: /
          pathType: Prefix
          backend:
            service:
              name: "nginx-service"
              port:
                number: 80

index.html

<!DOCTYPE html>
<html>

<body>
    <h1>Welcome to your customized nginx!</h1>
    <p>You modified the file on this running pod</p>
</body>

</html>