Creazione di un bilanciatore del carico dell'applicazione (ALB)

Questo argomento mostra come configurare un bilanciatore del carico delle applicazioni (ALB) AWS con GKE su AWS.

Prima di iniziare

Prima di iniziare a utilizzare GKE su AWS, assicurati di aver eseguito le seguenti attività:

  • Disporre delle autorizzazioni per creare criteri, ruoli e utenti AWS IAM per il bilanciatore del carico.
  • Installa un servizio di gestione.
  • Crea un cluster utente. Se utilizzi Workload Identity, crea un cluster utente con Workload Identity.
  • Dalla directory anthos-aws, utilizza anthos-gke per cambiare contesto al cluster utente.
    cd anthos-aws
    env HTTPS_PROXY=http://localhost:8118 \
      anthos-gke aws clusters get-credentials CLUSTER_NAME
    Sostituisci CLUSTER_NAME con il nome del tuo cluster utente.
  • Installa lo strumento a riga di comando curl o uno strumento simile.

Tagging delle subnet

GKE su AWS richiede tag in subnet che contengono endpoint ALB. GKE su AWS applica automaticamente il tag a tutte le subnet specificate nel campo spec.Networking.ServiceLoadBalancerSubnetIDs della risorsa AWSCluster.

Se hai installato GKE su AWS in un VPC esistente o se vuoi utilizzare subnet aggiuntive, applica tag alle subnet in due o più zone di disponibilità AWS.

Configura ALB su GKE su AWS

Prima di poter creare un ALB, devi configurare GKE su AWS impostando le autorizzazioni AWS IAM e fornendo le chiavi di accesso.

Crea autorizzazioni AWS IAM

Per creare un ALB per il cluster utente, devi configurare un utente AWS IAM con le autorizzazioni per creare e utilizzare ALB.

  1. Scarica un criterio IAM per il controller Ingress ALB. Puoi consultare le norme su GitHub.

    curl -o iam-policy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.4.0/docs/install/iam_policy.json
    
  2. Utilizza lo strumento a riga di comando aws per creare un criterio IAM denominato ALBIngressControllerIAMPolicy.

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

    La risposta include l'Amazon Resource Name (ARN) del criterio IAM. Salva l'ARN per un utilizzo futuro.

Concedi l'accesso al bilanciatore del carico

In questa sezione, assocerai il criterio relativo agli utenti a un utente AWS IAM o a un ruolo IAM con un'identità del carico di lavoro configurata.

Utente IAM

  1. Utilizza lo strumento aws per creare un utente IAM per il controller Ingress ALB.

    aws iam create-user \
    --user-name ALB_CONTROLLER_USER_NAME
    

    Sostituisci ALB_CONTROLLER_USER_NAME con il nome utente che vuoi creare per il controller Ingress ALB.

  2. Allega ALBIngressControllerIAMPolicy al nome utente.

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

    Sostituisci quanto segue:

    • ALB_CONTROLLER_USER_NAME con il nome utente che vuoi creare per il controller Ingress ALB.
    • ALB_IAM_POLICY_ARN con l'ARN del criterio IAM che hai creato in precedenza.
  3. Crea una chiave di accesso AWS IAM per l'utente del controller ALB Ingress.

    aws iam create-access-key --user-name ALB_CONTROLLER_USER_NAME
    

    Sostituisci ALB_CONTROLLER_USER_NAME con il nome utente che vuoi creare per il controller Ingress ALB.

    Lo strumento a riga di comando aws stampa i dettagli della chiave di accesso.

    {
      "AccessKey": {
        "UserName": ALB_CONTROLLER_USER_NAME
        "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
        "Status": "Active",
        "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
        "CreateDate": "2020-07-23T17:53:58Z"
      }
    }
    
  4. Salva la chiave di accesso e la chiave di accesso segreta nelle variabili di ambiente. Utilizzerai questi dati per configurare il cluster utente.

    ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
    ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
    
  5. Crea un secret nel tuo cluster con la chiave di accesso e la chiave di accesso del secret. Il controller Ingress ALB utilizza questo secret per eseguire l'autenticazione in AWS e gestire ALB.

    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
    

Ruolo con Workload Identity

Completa i passaggi descritti in Creazione di un cluster utente con Workload Identity. Quando crei un criterio, utilizza l'ARN di ALBIngressControllerIAMPolicy per il valore EXISTING_AWS_POLICY.

Configura il cluster

Per configurare un ALB, devi installare i seguenti componenti nel tuo cluster utente:

  1. Esegui il deployment di cert-manager Jetstack installando il manifest da GitHub.

    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
    
  2. Scarica il manifest del controller del bilanciatore del carico AWS da GitHub:

    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
    
  3. Scegli se utilizzi un utente o un ruolo IAM con Workload Identity.

    Utente IAM

    Modifica il file v2_4_0_full.yaml e cerca kind: Deployment. Sostituisci l'oggetto Deployment con questa versione modificata.

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

    Sostituisci quanto segue:

    • AWS_ACCESS_KEY_ID: la chiave di accesso AWS generata durante la creazione di un utente AWS IAM
    • AWS_SECRET_ACCESS_KEY: la chiave di accesso secret AWS generata durante la creazione di un utente AWS IAM

    Ruolo con Workload Identity

    Modifica il file v2_4_0_full.yaml e cerca kind: Deployment. Sostituisci l'intero oggetto Deployment con questa versione modificata:

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

    Sostituisci quanto segue:

    • CLUSTER_UID: l'UID del cluster, ad esempio bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
    • AWS_VPC_ID: l'ID del VPC AWS, ad esempio vpc-1234567890abc
    • LB_CONTROLLER_ROLE_ARN: l'ARN del ruolo AWSLBControllerRole
    • AWS_REGION: la regione AWS del cluster, ad esempio us-east-1
  4. Applica il controller al cluster.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f v2_4_0_full.yaml
    

    GKE su AWS installa il controller Ingress ALB.

Creazione di una ALB

In questa sezione creerai un'ALB di esempio che serve un remake del gioco 2048.

  1. Copia la seguente configurazione YAML in un file denominato 2048.yaml. La configurazione crea uno spazio dei nomi, un servizio e un deployment Kubernetes. Il deployment è esposto tramite un comando Ingress.

    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. Utilizza kubectl per applicare la configurazione al cluster.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f 2048.yaml
    
  3. Usa kubectl per controllare lo stato della risorsa Ingress.

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

    Viene visualizzato lo stato della tua risorsa Ingress. La colonna ADDRESS contiene l'endpoint della tua risorsa Ingress.

    NAME           HOSTS   ADDRESS                                                             PORTS   AGE
    2048-ingress   *       123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com   80      2m19s
    
  4. Vai all'endpoint ALB in un browser. Ad esempio: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Viene visualizzato il gioco 2048.

Passaggi successivi