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

  • Avere autorizzazioni per creare criteri, ruoli e utenti AWS IAM per il bilanciatore di carica.
  • Installa un servizio di gestione.
  • Crea un cluster di utenti. Se utilizzi Workload Identity, crea un cluster utente con Workload Identity.
  • Dalla directory anthos-aws, utilizza anthos-gke per cambiare contesto e passare al cluster di utenti. 
    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 di utenti.
  • Installa lo strumento a riga di comando curl o un altro strumento simile.

Tagging delle subnet

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

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

Crea autorizzazioni IAM AWS

Per creare un ALB per il tuo cluster utente, devi configurare un utente IAM di AWS con le autorizzazioni per creare e gestire l'ALB.

  1. Scarica un criterio IAM per ALB Ingress Controller. 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 utilizzarlo in un secondo momento.

Concedi l'accesso al bilanciatore del carico

In questa sezione, associ il criterio utente a un utente AWS IAM o a un ruolo IAM con un'identità per il workload configurata.

Utente IAM

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

    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 ALB Ingress.

  2. Collega 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 ALB Ingress.
    • ALB_IAM_POLICY_ARN con l'ARN del criterio IAM 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 ALB Ingress.

    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. Li utilizzerai per configurare il cluster di utenti.

    ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY

  5. Crea un secret nel cluster con la chiave di accesso e la chiave di accesso segreta. Il controller ALB Ingress utilizza questo secret per autenticarsi ad AWS e gestire gli 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 identità di workload

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 di EXISTING_AWS_POLICY.

Configura il cluster

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

  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 l'identità del carico di lavoro.

    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 AWS IAM
    • AWS_SECRET_ACCESS_KEY: la chiave di accesso segreta AWS generata quando hai creato un utente AWS IAM

    Ruolo con identità di workload

    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 tuo 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 ALB Ingress.

Creazione di un ALB

In questa sezione crei 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 viene esposto utilizzando un 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 di Ingress. La colonna ADDRESS contiene l'endpoint di 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