Eine neue Version von GKE auf AWS wurde am 27. August veröffentlicht. In den Versionshinweisen finden Sie Informationen zu funktionsgefährdenden Änderungen.

Application Load Balancer (ALB) erstellen

In diesem Thema erfahren Sie, wie Sie einen AWS Application Load Balancer mit GKE on AWS einrichten.

Hinweis

Bevor Sie GKE on AWS verwenden, müssen die folgenden Bedingungen erfüllt sein:

  • Sie sind berechtigt, einen AWS IAM-Nutzer für den Load-Balancer zu erstellen.
  • Sie haben einen Verwaltungsdienst installiert.
  • Nutzercluster erstellen
  • Verwenden Sie im Verzeichnis anthos-aws anthos-gke, um den Kontext in Ihren Nutzercluster zu ändern.
        cd anthos-aws
        env HTTP_PROXY=http://localhost:8118 \
        anthos-gke aws clusters get-credentials [CLUSTER_NAME]
  • Installieren Sie das curl-Befehlszeilentool oder ein ähnliches Tool.
  • Sie haben Subnetze in zwei oder mehr Verfügbarkeitszonen für Ihr ALB erstellt oder ausgewählt.

ALB in GKE on AWS einrichten

Bevor Sie ALB erstellen können, müssen Sie ALB in GKE on AWS konfigurieren. Dafür richten Sie AWS IAM-Berechtigungen ein und stellen Zugriffsschlüssel für GKE on AWS bereit.

AWS IAM-Berechtigungen erstellen

Damit Sie einen ALB mit GKE on AWS erstellen können, müssen Sie einen AWS IAM-Nutzer mit Berechtigungen zum Erstellen und Ausführen von ALB einrichten.

  1. 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-alb-ingress-controller/v1.1.8/docs/examples/iam-policy.json
    
  2. Erstellen Sie mit dem aws-Tool eine IAM-Richtlinie mit dem Namen ALBIngressControllerIAMPolicy aus der heruntergeladenen Richtlinie.

    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.

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

  4. Hängen Sie ALBIngressControllerIAMPolicy an.

    aws iam attach-user-policy \
     --user-name ALB_CONTROLLER_USER_NAME \
     --policy-arn ALB_IAM_POLICY_ARN
    

    Ersetzen Sie:

    • 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.
  5. 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.

    {
      "AccessKey": {
        "UserName": ALB_CONTROLLER_USER_NAME
        "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
        "Status": "Active",
        "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
        "CreateDate": "2020-07-23T17:53:58Z"
      }
    }
    
  6. Speichern Sie den Zugriffsschlüssel und den geheimen Zugriffsschlüssel in Umgebungsvariablen. Sie verwenden diese, um GKE on AWS zu konfigurieren.

    ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
    ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
    

GKE on AWS konfigurieren

Wenn Sie ALB in GKE on AWS konfigurieren möchten, speichern Sie Ihre AWS IAM-Anmeldedaten als Kubernetes-Secret.

  1. Erstellen Sie ein Secret mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüsselpaar. Der ALB-Ingress-Controller verwendet dieses Secret, um sich bei AWS zu authentifizieren und ALBs zu verwalten.

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

ALB-Ingress-Controller bereitstellen

  1. Kopieren Sie das folgende YAML-Manifest in eine Datei mit dem Namen aws-alb-ingress-controller.yaml.

    # Original from GitHub: https://github.com/kubernetes-sigs/aws-alb-ingress-controller
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      labels:
        app.kubernetes.io/name: alb-ingress-controller
      name: alb-ingress-controller
      namespace: kube-system
    spec:
      selector:
        matchLabels:
          app.kubernetes.io/name: alb-ingress-controller
      template:
        metadata:
          labels:
            app.kubernetes.io/name: alb-ingress-controller
        spec:
          containers:
            - name: alb-ingress-controller
              args:
                - --ingress-class=alb
    
                # ID of your cluster. Used when naming resources created
                # by the ALB Ingress Controller, providing distinction between
                # clusters.
                - --cluster-name=CLUSTER_ID
    
                # AWS VPC ID this Ingress controller uses to create AWS resources.
                - --aws-vpc-id=AWS_VPC_ID
    
                # AWS region this Ingress controller operates in. Should match the region of your GKE on AWS cluster.
                - --aws-region=AWS_REGION
    
              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
    
              # Repository location of the ALB Ingress Controller.
              image: docker.io/amazon/aws-alb-ingress-controller:v1.1.8
          serviceAccountName: alb-ingress-controller
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRole
    metadata:
      labels:
        app.kubernetes.io/name: alb-ingress-controller
      name: alb-ingress-controller
    rules:
      - apiGroups:
          - ""
          - extensions
        resources:
          - configmaps
          - endpoints
          - events
          - ingresses
          - ingresses/status
          - services
          - pods/status
        verbs:
          - create
          - get
          - list
          - update
          - watch
          - patch
      - apiGroups:
          - ""
          - extensions
        resources:
          - nodes
          - pods
          - secrets
          - services
          - namespaces
        verbs:
          - get
          - list
          - watch
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRoleBinding
    metadata:
      labels:
        app.kubernetes.io/name: alb-ingress-controller
      name: alb-ingress-controller
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: ClusterRole
      name: alb-ingress-controller
    subjects:
      - kind: ServiceAccount
        name: alb-ingress-controller
        namespace: kube-system
    ---
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      labels:
        app.kubernetes.io/name: alb-ingress-controller
      name: alb-ingress-controller
      namespace: kube-system
    

    Ersetzen Sie dabei Folgendes:

    • CLUSTER_ID durch den Namen Ihres Nutzerclusters von GKE on AWS. Beispiel: gke-abcdef12.

    • AWS_VPC_ID durch die ID Ihrer AWS-VPC. Beispiel: vpc-1234567890abc.

    • AWS_REGION durch die AWS-Region Ihres Nutzerclusters. Beispiel: us-east-1.

    Weitere Informationen zu dieser Konfiguration finden Sie unter alb-ingress-controller im GitHub-Repository aws-alb-ingress-controller.

  2. Wenden Sie das Manifest auf Ihren Cluster an:

    env HTTP_PROXY=http://localhost:8118 \
      kubectl apply -f aws-alb-ingress-controller.yaml
    

ALB erstellen

In diesem Abschnitt erstellen Sie einen ALB, der ein Remake des Spiels 2048 bereitstellt.

  1. 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
    
  2. Verwenden Sie kubectl, um die Konfiguration auf Ihren Cluster anzuwenden:

    env HTTP_PROXY=http://localhost:8118 \
    kubectl apply -f 2048.yaml
    
  3. Verwenden Sie kubectl, um den Status der Ingress-Ressource zu prüfen.

    env HTTP_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
    
  4. 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.