Das in dieser Dokumentation beschriebene Produkt GKE on AWS befindet sich jetzt im Wartungsmodus und wird am 17. März 2027 eingestellt.

Diese Seite wurde von der Cloud Translation API übersetzt.

HTTP-Load-Balancer einrichten

Auf dieser Seite erfahren Sie, wie Sie einen Application Load Balancer (ALB) einrichten.

Weitere Informationen zu den anderen Load-Balancer-Typen, die GKE in AWS unterstützt, finden Sie unter Load Balancer – Übersicht.

Diese Seite richtet sich an Netzwerkexperten, die Netzwerkgeräte installieren, konfigurieren und unterstützen möchten. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir in Google Cloud -Inhalten verweisen, finden Sie unter Häufig verwendete GKE Enterprise-Nutzerrollen und -Aufgaben.

Hinweise

Bevor GKE on AWS einen ALB erstellen kann, müssen Sie:

Erstellen Sie einen GKE on AWS-Cluster und konfigurieren Sie den Zugriff darauf mit kubectl.
Den OIDC-Anbieter des Clusters bei AWS registrieren.

Übersicht

So erstellen Sie den ersten ALB in einem Cluster:

Identifizieren und taggen bzw. annotieren Sie die Subnetze in Ihrer VPC, in denen die AlBs bereitgestellt werden sollen.
Erstellen Sie eine AWS-Rolle, die dem ALB-Controller Zugriff auf AWS-Ressourcen gewährt.
Installieren Sie das Open-Source-Tool aws-load-balancer-controller.
Erstellen Sie eine ALB-Konfiguration und stellen Sie sie bereit.

Zum Erstellen nachfolgender ALBs müssen Sie nur eine weitere ALB-Konfiguration erstellen und bereitstellen.

Application Load Balancer erstellen

Subnetze für Ihr ALB taggen

Bevor Sie einen ALB erstellen, müssen Sie AWS mitteilen, in welchen Subnetzen er ausgeführt werden soll. Die übliche Methode besteht darin, das Subnetz so zu taggen, das es für die automatische Erkennung als verfügbar identifiziert wird. Alternativ können Sie dem Ingress-Objekt eine Anmerkung hinzufügen, um die Subnetze, in denen es ausgeführt werden soll, explizit aufzulisten.

Informationen zum Taggen Ihrer ausgewählten Subnetze als für die automatische Erkennung verfügbar, finden Sie unter Dienst-Load-Balancer-Subnetze taggen.

Wenn Sie das Ingress-Objekt mit einer Liste von Subnetzen annotieren möchten, fügen Sie dem Kubernetes Ingress-Objekt eine Anmerkung mit dem Namen alb.ingress.kubernetes.io/subnets hinzu. Legen Sie den Wert der Annotation auf eine durch Kommas getrennte Liste von Subnetz-IDs oder Subnetznamen fest, z. B. subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef.

AWS IAM-Berechtigungen erstellen

Laden Sie die IAM-Richtlinie für den AWS-Load-Balancer-Controller herunter. Diese Richtlinie gibt die Berechtigungen an, die der Load-Balancer-Controller benötigt. Sie können die Richtlinie auf GitHub nachlesen. Mit diesem Befehl wird die Richtlinie in einer Datei mit dem Namen iam_policy.json gespeichert.

  curl -Lo iam_policy.json \
    https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.4.4/docs/install/iam_policy.json

Verwenden Sie diese Datei, um eine IAM-Richtlinie mit dem Namen AWSLoadBalancerControllerIAMPolicy zu erstellen:

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

Zugriff auf den Load-Balancer gewähren

Erstellen Sie eine AWS-IAM-Rolle für das Dienstkonto des Controllers. Folgen Sie dazu der Anleitung unter AWS-IAM-Rolle erstellen. Ersetzen Sie in dieser Anleitung Folgendes:

AWS_POLICY_ARN: der ARN der AWSLoadBalancerControllerIA-Richtlinie, die im vorherigen Schritt erstellt wurde
KSA_NAME: "aws-load-balancer-controller"
K8S_NAMESPACE: "kube-system"
AWS_ROLE_NAME: "AWSLBControllerRole"

Führen Sie diesen Befehl aus, um den ARN der Richtlinie abzurufen:

aws iam list-policies \
  --query 'Policies[?PolicyName==`AWSLoadBalancerControllerIAMPolicy`].Arn' \
  --output text

AWS-Load-Balancer-Controller installieren

Extrahieren und speichern Sie dazu die folgenden Werte. Sie benötigen sie später.

Sie können die UID Ihres Clusters mit dem folgenden Befehl ermitteln:
```
  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(uid)"
```
Sie finden die VPC-ID Ihres Clusters, indem Sie den folgenden Befehl ausführen:
```
  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(networking.vpcId)"
```
Sie können den ARN der Rolle AWSLBControllerRole mit dem folgenden Befehl ermitteln:
```
aws iam get-role --role-name AWSLBControllerRole --query Role.Arn --output text
```
Sie können die AWS-Region Ihres Clusters mit dem folgenden Befehl ermitteln:
```
gcloud container aws clusters describe CLUSTER_NAME \
  --location GOOGLE_CLOUD_LOCATION \
  --format "value(awsRegion)"
```
Ersetzen Sie:
- GOOGLE_CLOUD_LOCATION durch den Namen der Google-Region, die Ihrem Cluster zugeordnet ist.
- CLUSTER_NAME durch den Namen Ihres Clusters.

Installieren Sie cert-manager mit dem folgenden Befehl:

kubectl apply \
  --validate=false \
  -f https://github.com/jetstack/cert-manager/releases/download/v1.10.0/cert-manager.yaml

Laden Sie das Manifest für aws-load-balancer-controller herunter und speichern Sie es mit dem folgenden Befehl in der lokalen Datei v2_4_4_full.yaml:
```
curl -Lo v2_4_4_full.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.4.4/v2_4_4_full.yaml
```

Bearbeiten Sie die Datei v2_4_4_full.yaml und suchen Sie nach kind: Deployment. Ersetzen Sie das Objekt Deployment durch diese geänderte Version:

kind: Deployment
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/name: aws-load-balancer-controller
  name: aws-load-balancer-controller
  namespace: kube-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/component: controller
      app.kubernetes.io/name: aws-load-balancer-controller
  template:
    metadata:
      labels:
        app.kubernetes.io/component: controller
        app.kubernetes.io/name: aws-load-balancer-controller
    spec:
      containers:
      - args:
        - --cluster-name=CLUSTER_UID
        - --aws-region=AWS_REGION
        - --aws-vpc-id=AWS_VPC_ID
        - --ingress-class=alb
        - --disable-restricted-sg-rules=true
        image: amazon/aws-alb-ingress-controller:v2.4.4
        env:
        - name: AWS_ROLE_ARN
          value: AWS_ROLE_ARN
        - name: AWS_WEB_IDENTITY_TOKEN_FILE
          value: /var/run/secrets/aws-load-balancer-controller/serviceaccount/token
        livenessProbe:
          failureThreshold: 2
          httpGet:
            path: /healthz
            port: 61779
            scheme: HTTP
          initialDelaySeconds: 30
          timeoutSeconds: 10
        name: controller
        ports:
        - containerPort: 9443
          name: webhook-server
          protocol: TCP
        resources:
          limits:
            cpu: 200m
            memory: 500Mi
          requests:
            cpu: 100m
            memory: 200Mi
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          runAsNonRoot: true
        volumeMounts:
        - mountPath: /tmp/k8s-webhook-server/serving-certs
          name: cert
          readOnly: true
        - mountPath: /var/run/secrets/aws-load-balancer-controller/serviceaccount
          name: aws-iam-token
          readOnly: true
      priorityClassName: system-cluster-critical
      securityContext:
        fsGroup: 1337
      serviceAccountName: aws-load-balancer-controller
      terminationGracePeriodSeconds: 10
      volumes:
      - name: cert
        secret:
          defaultMode: 420
          secretName: aws-load-balancer-webhook-tls
      - name: aws-iam-token
        projected:
          defaultMode: 420
          sources:
          - serviceAccountToken:
              audience: sts.amazonaws.com
              expirationSeconds: 86400
              path: token
---

Dabei gilt:

CLUSTER_UID: die UID Ihres Clusters, z. B. bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
AWS_VPC_ID: die ID Ihrer AWS-VPC, z. B. vpc-1234567890abc.
AWS_ROLE_ARN: der ARN der Rolle AWSLBControllerRole
AWS_REGION: die AWS-Region Ihres Clusters, z. B. us-east-1

Wenden Sie das geänderte Manifest mit dem folgenden Befehl auf Ihren Cluster an:
```
kubectl apply -f v2_4_4_full.yaml
```

Prüfen Sie mit dem folgenden Befehl, ob der Load Balancer-Controller ausgeführt wird:

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

Die Ausgabe sollte in etwa so aussehen:aws-load-balancer-controller

NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   1/1     1            1           51s

Beispiel-ALB erstellen

In diesem Abschnitt wird gezeigt, wie Sie ein Beispiel-ALB erstellen, das ein Remake des Spiels 2048 bereitstellt.

Kopieren Sie die folgende YAML-Konfiguration in eine Datei mit dem Namen 2048.yaml. Die Konfiguration erstellt einen Kubernetes-Namespace, -Dienst und ein Kubernetes-Deployment. Das Deployment wird über einen Ingress-ALB bereitgestellt.

apiVersion: v1
kind: Namespace
metadata:
  name: game-2048
---
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: game-2048
  name: deployment-2048
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: app-2048
  replicas: 5
  template:
    metadata:
      labels:
        app.kubernetes.io/name: app-2048
    spec:
      containers:
      - image: alexwhen/docker-2048
        imagePullPolicy: Always
        name: app-2048
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  namespace: game-2048
  name: service-2048
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  type: NodePort
  selector:
    app.kubernetes.io/name: app-2048
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: game-2048
  name: ingress-2048
  annotations:
    alb.ingress.kubernetes.io/scheme: internet-facing
spec:
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: service-2048
                port:
                  number: 80

Wenden Sie die Konfiguration mit dem folgenden Befehl auf Ihren Cluster an:
```
kubectl apply -f 2048.yaml
```

Prüfen Sie den Status der Ingress-Ressource mit dem folgenden Befehl:

kubectl get ingress -n game-2048 ingress-2048

Die Befehlsausgabe sieht in etwa so aus: Die Spalte ADDRESS enthält den Endpunkt des Ingress.

 NAME           CLASS    HOSTS   ADDRESS                                                                   PORTS   AGE
 ingress-2048   <none>   *       k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com   80      2m19s
 ```

Rufen Sie den ALB-Endpunkt in einem Browser auf. Beispiel: http://k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com. Das Spiel 2048 wird angezeigt. Es zeigt, dass Sie Ihren ALB-Load-Balancer erfolgreich bereitgestellt und konfiguriert haben.

Bereinigen

Entfernen Sie das Manifest mit dem folgenden Befehl, um das im vorherigen Schritt erstellte ALB- und Bereitstellungs-Beispiel zu entfernen:

kubectl delete -f 2048.yaml

HTTP-Load-Balancer einrichten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.