Wie richte ich den AWS Load Balancer Controller auf einem Amazon EKS-Cluster für Fargate ein?

Behebung

Hinweis: Wenn du beim Ausführen von AWS Command Line Interface (AWS CLI)-Befehlen Fehlermeldungen erhältst, findest du weitere Informationen dazu unter Problembehandlung bei der AWS CLI. Stelle außerdem sicher, dass du die neueste Version der AWS CLI verwendest.

Du kannst den AWS Load Balancer Controller einrichten, ohne dass bereits Application Load Balancer Ingress Controller-Bereitstellungen vorhanden sind.

Voraussetzungen:

• Deinstalliere den bestehenden AWS ALB Ingress Controller für Kubernetes. Der AWS Load Balancer Controller ersetzt seine Funktionalität.
• Verwende eksctl Version 0.109.0 oder höher. Weitere Informationen findest du unter Installation auf der eksctl-Website.
• Installiere Helm auf deiner Workstation.

Einen Amazon EKS-Cluster, eine Service AWS-Konto-Richtlinie und rollenbasierte Zugriffskontrollrichtlinien erstellen

Führe die folgenden Schritte aus:

1. Führe den folgenden Befehl aus, um eksctl zum Erstellen eines Amazon-EKS-Clusters zu verwenden:

   eksctl create cluster \
     --name YOUR_CLUSTER_NAME \
     --version 1.28 \
     --fargate

   Hinweis: Ersetze YOUR_CLUSTER_NAME durch deinen Cluster-Namen. Du musst keine Fargate-Pod-Ausführungsrolle für Cluster erstellen, die nur Fargate-Pods verwenden (--fargate).

2. Damit der Cluster AWS Identity and Access Management (IAM, Identitäts- und Zugriffsmanagement) für Servicekonten verwenden kann, führe den folgenden Befehl aus:

   eksctl utils associate-iam-oidc-provider \
     --cluster YOUR_CLUSTER_NAME \
     --approve

   Hinweis: Ersetze YOUR_CLUSTER_NAME durch deinen Cluster-Namen. kubelet und kube-proxy verwenden FargateExecutionRole, um den Fargate-Pod auszuführen. FargateExecutionRole ist jedoch nicht die IAM-Rolle des Fargate-Pods. Für Fargate-Pods musst du die IAM-Rolle für das Servicekonto verwenden.

3. Führe den folgenden Befehl aus, um eine IAM-Richtlinie herunterzuladen, die es dem AWS Load Balancer Controller ermöglicht, in deinem Namen Aufrufe an AWS-APIs zu tätigen:

4.  curl -o iam_policy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.11.0/docs/install/iam_policy.json

5. Um eine IAM-Richtlinie mit der heruntergeladenen Richtlinie zu erstellen, führe den folgenden AWS-CLI-Befehl create-policy aus:

   aws iam create-policy \
     --policy-name AWSLoadBalancerControllerIAMPolicy \
     --policy-document file://iam_policy.json

6. Führe den folgenden Befehl aus, um ein Servicekonto für den AWS Load Balancer Controller zu erstellen:

   eksctl create iamserviceaccount \
     --cluster=YOUR_CLUSTER_NAME \
     --namespace=kube-system \
     --name=aws-load-balancer-controller \
     --attach-policy-arn=arn:aws:iam::AWS_ACCOUNT_ID:policy/AWSLoadBalancerControllerIAMPolicy \
     --override-existing-serviceaccounts \
     --approve

   Hinweis: Ersetze YOUR_CLUSTER_NAME durch deinen Cluster-Namen und AWS_ACCOUNT_ID durch deine Konto-ID. Der vorhergehende Befehl erstellt ein Servicekonto mit dem Namen aws-load-balancer-controller im kube-system-Namespace.

7. Führe einen der folgenden Befehle aus, um zu überprüfen, ob die neue Servicerolle erstellt wurde:

   eksctl get iamserviceaccount \
     --cluster=YOUR_CLUSTER_NAME \
     --name=aws-load-balancer-controller \
     --namespace=kube-system

   Hinweis: Ersetze YOUR_CLUSTER_NAME durch deinen Cluster-Namen.
   -oder-

   kubectl get serviceaccount aws-load-balancer-controller \
     --namespace kube-system \
     -o yaml

Den AWS Load Balancer Controller mit Helm installieren

Führe die folgenden Schritte aus:

1. Führe den folgenden Befehl aus, um den Amazon-EKS-Chart zu Helm hinzuzufügen:

   helm repo add eks https://aws.github.io/eks-charts

2. Führe den folgenden Befehl aus, um das Repository zu aktualisieren und den neuesten Chart abzurufen:

   helm repo update eks

3. Führe den folgenden Befehl aus, um den Helm-Chart zu installieren:

   helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
     --set clusterName=YOUR_CLUSTER_NAME \
     --set serviceAccount.create=false \
     --set region=YOUR_REGION_CODE \
     --set vpcId=EKS_CLUSTER_VPC_ID \
     --set serviceAccount.name=aws-load-balancer-controller \
     --version 1.11.0 \
     -n kube-system

   Hinweis: Ersetze YOUR_CLUSTER_NAME durch den Namen deines Clusters und YOUR_REGION_CODE durch die AWS-Region deines Clusters. Ersetze außerdem EKS_CLUSTER_VPC_ID durch die Virtual Private Cloud (VPC)-ID des Clusters.

4. Führe den folgenden Befehl aus, um zu überprüfen, ob der Controller korrekt installiert wurde:

   kubectl get deployment -n kube-system aws-load-balancer-controller

   Beispielausgabe:

   NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
   aws-load-balancer-controller   2/2     2            2           84s

Den AWS Load Balancer Controller testen

Um die Implementierung zu testen, verwende den AWS Load Balancer Controller, um eine der folgenden Ressourcen zu erstellen:

• Ein Application Load Balancer für Ingress
• Ein Network Load Balancer, wobei für Service der Typ LoadBalancer ist

Eine Ingress-Ressource leitet den Datenverkehr auf der Grundlage von Web-Konzepten wie URIs, Hostnamen und Pfaden an verschiedene Services weiter. Es hat sich bewährt, eine ingress-Ressource zu verwenden, um einen Load Balancer mit mehreren Services gemeinsam zu nutzen oder das Service-Routing zu steuern. Verwende einen Service-LoadBalancer, um dem Service einen dedizierten Load Balancer zuzuweisen.

Hinweis: In den folgenden Testschritten wird eine Musterspielanwendung namens 2048 bereitgestellt.

Einen Application Load Balancer erstellen

Gehe wie folgt vor, um einen Application Load Balancer für Ingress zu erstellen:

1. Führe den folgenden Befehl aus, um das Fargate-Profil zu erstellen, das für die Spielbereitstellung erforderlich ist:

   eksctl create fargateprofile \
     --cluster YOUR_CLUSTER_NAME \
     --region YOUR_REGION_CODE \
     --name your-alb-sample-app \
     --namespace game-2048

   Hinweis: Ersetze YOUR_CLUSTER_NAME durch den Namen deines Clusters und YOUR_REGION_CODE durch deine Region.

2. Führe den folgenden Befehl aus, um die Anwendung bereitzustellen:

   kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.11.0/docs/examples/2048/2048_full.yaml

3. Warte ein paar Minuten. Führe dann den folgenden Befehl aus, um zu überprüfen, ob der AWS Load Balancer Controller eine Ingress-Ressource erstellt hat:

   kubectl get ingress/ingress-2048 -n game-2048

   Beispielausgabe:

   NAME         CLASS HOSTS ADDRESS                                                                PORTS AGE
   ingress-2048 alb   *     k8s-game2048-ingress2-xxxxxxxxxx-yyyyyyyyyy.region.elb.amazonaws.com   80    3d4h

   Wenn du nach einigen Minuten keine Ingress-Ressource siehst, führe den folgenden Befehl aus, um die AWS Load Balancer Controller-Protokolle anzuzeigen:

   kubectl logs -n kube-system deployment.apps/aws-load-balancer-controller

   Suche in den Protokollen nach Fehlermeldungen, die dir bei der Diagnose von Problemen mit der Bereitstellung helfen.

4. Um die Anwendung anzuzeigen, öffne einen Browser und navigiere dann in der Ausgabe des Ingress-Resourcen-Befehls zur URL.
   Hinweis: Wenn du die Anwendung nicht siehst, warte ein paar Minuten und aktualisiere deinen Browser.

Einen Network Load Balancer erstellen

Gehe wie folgt vor, um eine Anwendung mit dem IP-Adressmodus-Service für den Network Load Balancer bereitzustellen:

1. Führe den folgenden Befehl aus, um ein Fargate-Profil zu erstellen:

   eksctl create fargateprofile --cluster your-cluster --region your-region-code --name your-alb-sample-app --namespace game-2048

   Hinweis: Ersetze your-cluster durch den Namen deines Clusters und your-region-code durch die Region deines Clusters.

2. Führe den folgenden Befehl aus, um das Manifest für die Bereitstellung des 2048-Spiels abzurufen:

   curl -o 2048-game.yaml https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.11.0/docs/examples/2048/2048_full.yaml

3. Lösche im Manifest den folgenden Ingress-Abschnitt:

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     namespace: game-2048
     name: ingress-2048
     annotations:
       alb.ingress.kubernetes.io/scheme: internet-facing
       alb.ingress.kubernetes.io/target-type: ip
   spec:
     ingressClassName: alb
     rules:
       - http:
           paths:
             - path: /
               pathType: Prefix
               backend:
                 service:
                   name: service-2048           
                   port:
                     number: 80

4. Ändere das Service-Objekt so, dass es die folgenden Werte verwendet:

   apiVersion: v1
   kind: Service
   metadata:
     namespace: game-2048
     name: service-2048
     annotations:
       service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: "ip"
       service.beta.kubernetes.io/aws-load-balancer-type: external
       service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
   spec:
     ports:
       - port: 80
         targetPort: 80
         protocol: TCP
     type: LoadBalancer
     selector:
       app.kubernetes.io/name: app-2048

5. Führe den folgenden Befehl aus, um das Service- und Bereitstellungsmanifest zu erstellen:

   kubectl apply -f 2048-game.yaml

6. Führe den folgenden Befehl aus, um die Serviceerstellung und den DNS-Namen des Network Load Balancers zu überprüfen:

   kubectl get svc -n game-2048

   Beispielausgabe:

   NAME           TYPE           CLUSTER-IP       EXTERNAL-IP                                                               PORT(S)        AGE
   service-2048   LoadBalancer   10.100.114.197   k8s-game2048-service2-xxxxxxxxxx-yyyyyyyyyy.us-east-2.elb.amazonaws.com   80:xxxxx/TCP   23m

7. Warte einige Minuten, bis der Load Balancer aktiv ist. Öffne einen Webbrowser, um zu überprüfen, ob du auf die Bereitstellung zugreifen kannst. Öffne dann den vollqualifizierten Domain-Namen (FQDN) in der Befehlsausgabe unter EXTERNAL-IP.

Beheben von Problemen mit dem AWS Load Balancer Controller

Wenn du bei der Einrichtung des AWS Load Balancer Controllers auf Probleme stößt, führe die folgenden Befehle aus:

kubectl logs -n kube-system deployment.apps/aws-load-balancer-controller
kubectl get endpoints -n game-2048
kubectl get ingress/ingress-2048 -n game-2048

Überprüfe die Ausgabe des Befehls logs auf Fehlermeldungen, z. B. Probleme mit Tags oder Subnetzen. Schritte zur Behebung häufiger Fehler findest du unter Issues (Probleme) auf der GitHub-Website. Weitere Informationen findest du unter Wie kann ich Probleme beheben, wenn ich den AWS Load Balancer Controller verwende, um einen Load Balancer zu erstellen?

Der Befehl get endpoints zeigt dir, ob du die unterstützten Bereitstellungs-Pods korrekt registriert hast. Die Befehle get ingress zeigen dir, ob die Ingress-Ressourcen bereitgestellt werden.

Weitere Informationen findest du unter AWS Load Balancer Controller auf der Kubernetes-Website.