Créer un équilibreur de charge d'application (ALB)

Cette rubrique explique comment configurer un équilibreur de charge d'application (ALB) avec GKE sur AWS.

Avant de commencer

Avant de commencer à utiliser GKE sur AWS, veillez à effectuer les tâches suivantes :

  • Vérifiez que vous disposez des autorisations nécessaires pour créer des stratégies, rôles et utilisateurs IAM AWS pour l'équilibreur de charge.
  • Installez un service de gestion.
  • Créez un cluster d'utilisateur. Si vous utilisez Workload Identity, créez un cluster d'utilisateur avec Workload Identity.
  • À partir de votre répertoire anthos-aws, utilisez anthos-gke pour basculer vers le contexte de votre cluster d'utilisateur.
    cd anthos-aws
    env HTTPS_PROXY=http://localhost:8118 \
      anthos-gke aws clusters get-credentials CLUSTER_NAME
    Remplacez CLUSTER_NAME par le nom de votre cluster d'utilisateur.
  • Installez l'outil de ligne de commande curl ou un outil similaire.

Balisage des sous-réseaux

Dans GKE sur AWS, les sous-réseaux qui contiennent des points de terminaison ALB doivent disposer d'un tag. Le service ajoute automatiquement un tag à tous les sous-réseaux spécifiés dans le champ spec.Networking.ServiceLoadBalancerSubnetIDs de la ressource AWSCluster.

Si vous avez installé GKE sur AWS dans un VPC existant ou si vous souhaitez utiliser des sous-réseaux supplémentaires, appliquez des tags aux sous-réseaux dans au moins deux zones de disponibilité AWS.

Configurer ALB sur GKE sur AWS

Avant de pouvoir créer ALB, vous devez configurer des clusters GKE sur AWS en configurant des autorisations IAM AWS et en fournissant des clés d'accès.

Créer des autorisations IAM AWS

Pour créer un ALB pour votre cluster d'utilisateur, vous devez configurer un utilisateur IAM AWS disposant des autorisations nécessaires pour créer et exploiter l'ALB.

  1. Téléchargez une stratégie IAM pour le contrôleur d'entrée ALB. Vous pouvez consulter la stratégie sur 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. Utilisez l'outil de ligne de commande aws pour créer une stratégie IAM nommée ALBIngressControllerIAMPolicy.

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

    La réponse inclut le nom ARN (Amazon Resource Name) de la stratégie IAM. Enregistrez le nom ARN pour une utilisation ultérieure.

Accorder l'accès à votre équilibreur de charge

Dans cette section, vous associez la règle relative aux utilisateurs à un utilisateur IAM AWS ou à un rôle IAM avec Workload Identity configuré.

Utilisateur IAM

  1. Utilisez l'outil aws pour créer un utilisateur IAM pour le contrôleur d'entrée ALB.

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

    Remplacez ALB_CONTROLLER_USER_NAME par le nom d'utilisateur que vous souhaitez créer pour votre contrôleur d'entrée ALB.

  2. Associez la stratégie ALBIngressControllerIAMPolicy au nom d'utilisateur.

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

    Remplacez l'élément suivant :

    • ALB_CONTROLLER_USER_NAME par le nom d'utilisateur que vous souhaitez créer pour votre contrôleur d'entrée ALB.
    • ALB_IAM_POLICY_ARN par le nom ARN de la stratégie IAM que vous avez créée précédemment.
  3. Créez une clé d'accès AWS IAM pour l'utilisateur du contrôleur d'entrée ALB.

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

    Remplacez ALB_CONTROLLER_USER_NAME par le nom d'utilisateur que vous souhaitez créer pour votre contrôleur d'entrée ALB.

    L'outil de ligne de commande aws affiche les détails de la clé d'accès.

    {
      "AccessKey": {
        "UserName": ALB_CONTROLLER_USER_NAME
        "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
        "Status": "Active",
        "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
        "CreateDate": "2020-07-23T17:53:58Z"
      }
    }
    
  4. Enregistrez la clé d'accès et la clé d'accès secrète dans des variables d'environnement. Vous en aurez besoin pour configurer votre cluster d'utilisateur.

    ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
    ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
    
  5. Créez un secret dans votre cluster avec la clé d'accès et la clé d'accès secrète. Le contrôleur d'entrée ALB utilise ce secret pour s'authentifier auprès d'AWS et gérer les 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
    

Rôle avec Workload Identity

Suivez la procédure décrite dans la section Créer un cluster d'utilisateur avec Workload Identity. Lorsque vous créez une règle, utilisez l'ARN de ALBIngressControllerIAMPolicy pour la valeur de EXISTING_AWS_POLICY.

Configurer le cluster

Pour configurer un ALB, vous devez installer les composants suivants dans votre cluster d'utilisateur :

  1. Déployez le gestionnaire de certificats Jetstack en installant le fichier manifeste à partir de 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. Téléchargez le fichier manifeste du contrôleur d'équilibreur de charge AWS à partir de 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. Indiquez si vous utilisez un utilisateur IAM ou un rôle avec Workload Identity.

    Utilisateur IAM

    Modifiez le fichier v2_4_0_full.yaml et recherchez kind: Deployment. Remplacez l'objet de déploiement par cette version modifiée :

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

    Remplacez les éléments suivants :

    • AWS_ACCESS_KEY_ID : clé d'accès AWS générée lors de la création d'un utilisateur IAM AWS
    • AWS_SECRET_ACCESS_KEY : clé d'accès secrète AWS générée lors de la création d'un utilisateur IAM AWS

    Rôle avec Workload Identity

    Modifiez le fichier v2_4_0_full.yaml et recherchez kind: Deployment. Remplacez tout l'objet Deployment par cette version modifiée :

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

    Remplacez les éléments suivants :

    • CLUSTER_UID : UID unique de votre cluster, par exemple bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
    • AWS_VPC_ID : ID de votre VPC AWS, par exemple vpc-1234567890abc
    • LB_CONTROLLER_ROLE_ARN : ARN du rôle AWSLBControllerRole
    • AWS_REGION : région AWS de votre cluster, par exemple us-east-1
  4. Appliquez le contrôleur à votre cluster.

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

    GKE sur AWS installe le contrôleur d'entrée ALB.

Créer un ALB

Dans cette section, vous allez créer un exemple d'ALB qui diffuse un remake du jeu 2048.

  1. Copiez la configuration YAML suivante dans un fichier nommé 2048.yaml. La configuration crée un espace de noms Kubernetes, un service et un déploiement. Le déploiement est exposé à l'aide d'un objet 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. Utilisez kubectl pour appliquer la configuration à votre cluster :

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f 2048.yaml
    
  3. Utilisez kubectl pour vérifier l'état de la ressource d'entrée Ingress.

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

    L'état de votre objet Ingress s'affiche. La colonne ADDRESS contient le point de terminaison de votre entrée.

    NAME           HOSTS   ADDRESS                                                             PORTS   AGE
    2048-ingress   *       123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com   80      2m19s
    
  4. Accédez au point de terminaison ALB dans un navigateur. Par exemple : http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Le jeu 2048 s'affiche.

Étapes suivantes