Le produit décrit dans cette documentation, Anthos Clusters on AWS (génération précédente), est désormais en mode de maintenance. Toutes les nouvelles installations doivent utiliser le produit de génération actuelle, Anthos Clusters on AWS.

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 :

Remplissez les conditions préalables.

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.

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

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

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.
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.
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"
  }
}
```
Avertissement : Vous ne pourrez pas récupérer la clé secrète après ce point. Enregistrer la clé pour l'utiliser plus tard.
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
```
Remarque : Vous avez également besoin de la clé d'accès et de la clé secrète dans la section suivante.
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.
Important : Assurez-vous que votre contexte est défini sur le cluster d'utilisateur sur lequel vous souhaitez activer 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 :

Le Jetstack cert-manager pour générer et gérer des certificats TLS pour les ressources ALB de votre cluster
Le contrôleur d'équilibreur de charge AWS pour provisionner et gérer les ALB

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

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

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

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.

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

Utilisez kubectl pour appliquer la configuration à votre cluster :

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

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

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

Consultez la documentation du contrôleur d'entrée ALB.