Creazione di un bilanciatore del carico delle applicazioni (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 operazioni:

• Completa i prerequisiti.

• Disporre delle autorizzazioni per creare policy, ruoli e utenti AWS IAM per il load balancer.
• 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 passare al contesto del 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 cluster utente.
• Installa lo strumento a riga di comando curl o uno strumento simile.

Tagging delle subnet

GKE su AWS richiede tag sulle subnet che contengono endpoint ALB. GKE su AWS tagga automaticamente tutte le subnet specificate nel campo spec.Networking.ServiceLoadBalancerSubnetIDs della risorsa AWSCluster.

Se hai installato GKE su AWS in un VPC esistente o 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, configura GKE su AWS impostando le autorizzazioni AWS IAM e fornendo le chiavi di accesso.

Crea autorizzazioni IAM AWS

Per creare un ALB per il cluster utente, devi configurare un utente IAM AWS con le autorizzazioni per creare e gestire l'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 una policy IAM denominata 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 utilizzarlo in un secondo momento.

Concedere l'accesso al bilanciatore del carico

In questa sezione, associ il criterio utente a un utente IAM AWS o a un ruolo IAM con un'identità del workload 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. Aggiungi 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 IAM AWS per l'utente del controller Ingress ALB.

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

   Attenzione: non puoi recuperare la chiave segreta dopo questo punto. Salva la chiave per utilizzarla in un secondo momento.

4. Salva la chiave di accesso e la chiave di accesso segreta nelle variabili di ambiente. Li utilizzerai per configurare il cluster utente.

   ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
   ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
   

   Nota: nella sezione seguente sono necessarie anche la chiave di accesso e la chiave segreta.

5. Crea un secret nel cluster con la chiave di accesso e la chiave di accesso segreta. Il controller Ingress ALB utilizza questo secret per autenticarsi su AWS e gestire i bilanciatori del carico delle applicazioni.

   Importante: assicurati che il contesto sia impostato sul cluster di utenti su cui vuoi attivare 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 una policy, utilizza l'ARN di ALBIngressControllerIAMPolicy per il valore di EXISTING_AWS_POLICY.

Configura il cluster

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

• cert-manager di Jetstack per generare e gestire i certificati TLS per le risorse ALB del cluster.
• Il controller del bilanciatore del carico AWS per il provisioning e la gestione dei bilanciatori del carico delle applicazioni.

1. Esegui il deployment di Jetstack cert-manager 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. Seleziona 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 quando hai creato un utente IAM AWS
   • AWS_SECRET_ACCESS_KEY: la chiave di accesso segreta AWS generata quando hai creato un utente IAM AWS

   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 della tua VPC AWS, ad esempio vpc-1234567890abc
   • LB_CONTROLLER_ROLE_ARN: l'ARN del ruolo AWSLBControllerRole
   • AWS_REGION: la regione AWS del tuo 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 un 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 un servizio, un deployment e uno spazio dei nomi Kubernetes. Il deployment viene esposto utilizzando un ingresso.

   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. Utilizza 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 dell'ingresso. La colonna ADDRESS contiene l'endpoint del tuo 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

• Leggi la documentazione del controller Ingress ALB.