Das in dieser Dokumentation beschriebene Produkt Anthos-Cluster in AWS (vorherige Generation) befindet sich jetzt im Wartungsmodus. Alle neuen Installationen müssen Anthos-Cluster in AWS der aktuellen Generation verwenden.

Application Load Balancer (ALB) erstellen

In diesem Thema erfahren Sie, wie Sie einen AWS Application Load Balancer (ALB) mit Anthos-Cluster auf AWS (GKE in AWS) einrichten.

Hinweis

Bevor Sie Anthos-Cluster auf AWS verwenden, führen Sie die folgenden Aufgaben aus:

Sie haben dafür gesorgt, dass die Voraussetzungen erfüllt sind.

Sie benötigen Berechtigungen zum Erstellen von AWS IAM-Richtlinien, -Rollen und -Nutzern für den Load-Balancer.
Der Verwaltungsdienst muss installiert sein.
Nutzercluster erstellen Wenn Sie eine Workload Identity verwenden, erstellen Sie einen Nutzercluster mit einer Workload Identity.
Verwenden Sie im Verzeichnis anthos-aws anthos-gke, um den Kontext zu Ihrem Nutzercluster zu wechseln.
```
cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
```
Ersetzen Sie CLUSTER_NAME durch den Nutzerclusternamen.
Installieren Sie das curl-Befehlszeilentool oder ein ähnliches Tool.

Subnetze taggen

Anthos-Cluster auf AWS erfordern Tags in Subnetzen, die ALB-Endpunkte enthalten. Anthos Clusters on AWS kennzeichnet automatisch alle Subnetze im Feld spec.Networking.ServiceLoadBalancerSubnetIDs der Ressource AWSCluster mit Tags.

Wenn Sie Anthos-Cluster auf AWS in einer vorhandenen VPC installiert haben oder zusätzliche Subnetze verwenden möchten, wenden Sie Tags auf Subnetze in zwei oder mehr AWS-Verfügbarkeitszonen an.

ALB in Anthos-Cluster auf AWS einrichten

Bevor Sie einen ALB erstellen können, müssen Sie Anthos-Cluster auf AWS konfigurieren, indem Sie AWS IAM-Berechtigungen einrichten und Zugriffsschlüssel bereitstellen.

AWS IAM-Berechtigungen erstellen

Sie müssen einen AWS IAM-Nutzer mit Berechtigungen zum Erstellen und Verwenden des ALB einrichten, um einen ALB für Ihren Nutzercluster zu erstellen.

Laden Sie eine IAM-Richtlinie für den ALB-Ingress-Controller herunter. Sie können die Richtlinie auf GitHub nachlesen.

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

Verwenden Sie das aws-Befehlszeilentool, um eine IAM-Richtlinie mit dem Namen ALBIngressControllerIAMPolicy zu erstellen.
```
aws iam create-policy \
  --policy-name ALBIngressControllerIAMPolicy \
  --policy-document file://iam-policy.json
```
Die Antwort enthält den Amazon Resource Name (ARN) der IAM-Richtlinie. Speichern Sie den ARN zur späteren Verwendung.

Zugriff auf den Load-Balancer gewähren

In diesem Abschnitt verknüpfen Sie die Nutzerrichtlinie entweder mit einem AWS IAM-Nutzer oder mit einer IAM-Rolle mit einer konfigurierten Workload Identity.

IAM-Nutzer

Erstellen Sie mit dem aws-Tool einen IAM-Nutzer für den ALB-Ingress-Controller.
```
aws iam create-user \
--user-name ALB_CONTROLLER_USER_NAME
```
Ersetzen Sie ALB_CONTROLLER_USER_NAME durch den Nutzernamen, den Sie für den ALB-Ingress-Controller erstellen möchten.
Hängen Sie ALBIngressControllerIAMPolicy an den Nutzernamen an.
```
aws iam attach-user-policy \
 --user-name ALB_CONTROLLER_USER_NAME \
 --policy-arn ALB_IAM_POLICY_ARN
```
Ersetzen Sie Folgendes:
- ALB_CONTROLLER_USER_NAME durch den Nutzernamen, den Sie für den ALB-Ingress-Controller erstellen möchten.
- ALB_IAM_POLICY_ARN durch den ARN der zuvor erstellten IAM-Richtlinie.
Erstellen Sie einen AWS IAM-Zugriffsschlüssel für den Nutzer des ILB-Ingress-Controllers.
```
aws iam create-access-key --user-name ALB_CONTROLLER_USER_NAME
```
Ersetzen Sie ALB_CONTROLLER_USER_NAME durch den Nutzernamen, den Sie für den ALB-Ingress-Controller erstellen möchten.

Das aws-Befehlszeilentool gibt die Details des Zugriffsschlüssels aus.
```
{
  "AccessKey": {
    "UserName": ALB_CONTROLLER_USER_NAME
    "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
    "Status": "Active",
    "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
    "CreateDate": "2020-07-23T17:53:58Z"
  }
}
```
Achtung: Nach diesem Schritt können Sie den geheimen Schlüssel nicht mehr abrufen. Speichern Sie den Schlüssel, um ihn später zu verwenden.
Speichern Sie den Zugriffsschlüssel und den geheimen Zugriffsschlüssel in Umgebungsvariablen. Sie verwenden diese zum Konfigurieren des Nutzerclusters.
```
ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
```
Hinweis: Außerdem benötigen Sie im folgenden Abschnitt den Zugriffsschlüssel und den geheimen Schlüssel.
Erstellen Sie in Ihrem Cluster ein Secret mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel. Der ALB-Ingress-Controller verwendet dieses Secret, um sich bei AWS zu authentifizieren und ALBs zu verwalten.

Wichtig: Achten Sie darauf, dass als Kontext der Nutzercluster festgelegt ist, für den Sie ALB aktivieren möchten.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl create secret generic alb-ingress-controller-creds \
  -n kube-system \
  --from-literal=access_key_id=$ALB_ACCESS_KEY_ID \
  --from-literal=secret_access_key=$ALB_SECRET_ACCESS_KEY
```

Rolle mit Workload Identity

Führen Sie die Schritte unter Nutzercluster mit Workload Identity erstellen aus. Verwenden Sie beim Erstellen einer Richtlinie den ARN von ALBIngressControllerIAMPolicy für den Wert von EXISTING_AWS_POLICY.

Cluster konfigurieren

Zur Konfiguration eines ALB müssen Sie die folgenden Komponenten in Ihrem Nutzercluster installieren:

Der Jetstack cert-manager zum Generieren und Verwalten von TLS-Zertifikaten für die ALB-Ressourcen Ihres Clusters
Der AWS-Load-Balancer-Controller zum Bereitstellen und Verwalten von ALBs

Stellen Sie den Jetstack-Zertifikat-Manager bereit, indem Sie das Manifest aus GitHub installieren.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply \
  --validate=false \
  -f https://github.com/jetstack/cert-manager/releases/download/v1.5.4/cert-manager.yaml

Laden Sie das AWS-Load-Balancer-Controller-Manifest von GitHub herunter:

curl -Lo v2_4_0_full.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.4.0/v2_4_0_full.yaml

Wählen Sie aus, ob Sie einen IAM-Nutzer oder eine Rolle mit Workload Identity verwenden.

IAM-Nutzer

Bearbeiten Sie die Datei v2_4_0_full.yaml und suchen Sie nach kind: Deployment. Ersetzen Sie das Objekt 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.0
        env:
        - name: AWS_ACCESS_KEY_ID
          valueFrom:
            secretKeyRef:
              name: alb-ingress-controller-creds
              key: access_key_id
        - name: AWS_SECRET_ACCESS_KEY
          valueFrom:
            secretKeyRef:
              name: alb-ingress-controller-creds
              key: secret_access_key
        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
      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
    ---

Ersetzen Sie Folgendes:

AWS_ACCESS_KEY_ID: der AWS-Zugriffsschlüssel, der beim Erstellen eines AWS IAM-Nutzers generiert wurde
AWS_SECRET_ACCESS_KEY: der geheime AWS-Zugriffsschlüssel, der beim Erstellen eines AWS IAM-Nutzers generiert wurde

Rolle mit Workload Identity

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

apiVersion: apps/v1
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.0
        env:
        - name: AWS_ROLE_ARN
          value: LB_CONTROLLER_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
---

Ersetzen Sie Folgendes:

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
LB_CONTROLLER_ROLE_ARN: der ARN der AWSLBControllerRole-Rolle
AWS_REGION: die AWS-Region Ihres Clusters, z. B. us-east-1

Wenden Sie den Controller auf Ihren Cluster an.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f v2_4_0_full.yaml
```
Anthos-Cluster auf AWS installieren den ALB-Ingress-Controller.

ALB erstellen

In diesem Abschnitt erstellen Sie einen ALB, der 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 mithilfe eines Ingress bereitgestellt.

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

Verwenden Sie kubectl, um die Konfiguration auf Ihren Cluster anzuwenden:
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f 2048.yaml
```

Verwenden Sie kubectl, um den Status der Ingress-Ressource zu prüfen.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get ingress -n 2048-game 2048-ingress

Der Status des Ingress wird angezeigt. Die Spalte ADDRESS enthält den Endpunkt des Ingress.

NAME           HOSTS   ADDRESS                                                             PORTS   AGE
2048-ingress   *       123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com   80      2m19s

Rufen Sie in einem Browser den ILB-Endpunkt auf. Beispiel: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Das Spiel 2048 erscheint.

Weitere Informationen

ALB-Ingress-Controller-Dokumentation lesen.