Une nouvelle version de GKE sur AWS a été publiée le 27 août. Pour en savoir plus sur les modifications destructives, consultez les notes de version.

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

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

Avant de commencer

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

  • Disposez des autorisations nécessaires pour créer un utilisateur AWS IAM pour l'équilibreur de charge.
  • Installez un service de gestion.
  • Créez un cluster d'utilisateur.
  • Dans votre répertoire anthos-aws, utilisez anthos-gke pour basculer vers le contexte de votre cluster d'utilisateur.
        cd anthos-aws
        env HTTP_PROXY=http://localhost:8118 \
        anthos-gke aws clusters get-credentials [CLUSTER_NAME]
  • Installez l'outil de ligne de commande curl ou un outil similaire.
  • Créez ou sélectionnez des sous-réseaux dans au moins deux zones de disponibilité pour votre ALB.

Configurer ALB sur GKE sur AWS

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

Créer des autorisations IAM AWS

Pour créer un ALB avec GKE sur AWS, 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-alb-ingress-controller/v1.1.8/docs/examples/iam-policy.json
    
  2. Utilisez l'outil aws pour créer une stratégie IAM nommée ALBIngressControllerIAMPolicy à partir de la stratégie que vous avez téléchargée.

    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.

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

  4. Associez ALBIngressControllerIAMPolicy.

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

    Remplacez :

    • 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 l'ARN de la stratégie IAM que vous avez créée précédemment.
  5. 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.

    {
      "AccessKey": {
        "UserName": ALB_CONTROLLER_USER_NAME
        "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
        "Status": "Active",
        "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
        "CreateDate": "2020-07-23T17:53:58Z"
      }
    }
    
  6. Enregistrez la clé d'accès et la clé d'accès secrète dans des variables d'environnement. Vous les utiliserez pour configurer GKE sur AWS.

    ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
    ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
    

Configurer GKE sur AWS

Pour configurer ALB sur GKE sur AWS, vous devez enregistrer vos identifiants IAM AWS en tant que secrets Kubernetes.

  1. Créez un secret avec la paire constituée de la clé d'accès et de 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 HTTP_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
    

Déployer le contrôleur d'entrée ALB

  1. Copiez le fichier YAML suivant dans un fichier nommé aws-alb-ingress-controller.yaml.

    # Original from GitHub: https://github.com/kubernetes-sigs/aws-alb-ingress-controller
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      labels:
        app.kubernetes.io/name: alb-ingress-controller
      name: alb-ingress-controller
      namespace: kube-system
    spec:
      selector:
        matchLabels:
          app.kubernetes.io/name: alb-ingress-controller
      template:
        metadata:
          labels:
            app.kubernetes.io/name: alb-ingress-controller
        spec:
          containers:
            - name: alb-ingress-controller
              args:
                - --ingress-class=alb
    
                # ID of your cluster. Used when naming resources created
                # by the ALB Ingress Controller, providing distinction between
                # clusters.
                - --cluster-name=CLUSTER_ID
    
                # AWS VPC ID this Ingress controller uses to create AWS resources.
                - --aws-vpc-id=AWS_VPC_ID
    
                # AWS region this Ingress controller operates in. Should match the region of your GKE on AWS cluster.
                - --aws-region=AWS_REGION
    
              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
    
              # Repository location of the ALB Ingress Controller.
              image: docker.io/amazon/aws-alb-ingress-controller:v1.1.8
          serviceAccountName: alb-ingress-controller
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRole
    metadata:
      labels:
        app.kubernetes.io/name: alb-ingress-controller
      name: alb-ingress-controller
    rules:
      - apiGroups:
          - ""
          - extensions
        resources:
          - configmaps
          - endpoints
          - events
          - ingresses
          - ingresses/status
          - services
          - pods/status
        verbs:
          - create
          - get
          - list
          - update
          - watch
          - patch
      - apiGroups:
          - ""
          - extensions
        resources:
          - nodes
          - pods
          - secrets
          - services
          - namespaces
        verbs:
          - get
          - list
          - watch
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRoleBinding
    metadata:
      labels:
        app.kubernetes.io/name: alb-ingress-controller
      name: alb-ingress-controller
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: ClusterRole
      name: alb-ingress-controller
    subjects:
      - kind: ServiceAccount
        name: alb-ingress-controller
        namespace: kube-system
    ---
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      labels:
        app.kubernetes.io/name: alb-ingress-controller
      name: alb-ingress-controller
      namespace: kube-system
    

    Remplacez les éléments suivants :

    • CLUSTER_ID par le nom de votre cluster d'utilisateur GKE sur AWS. Exemple :gke-abcdef12

    • AWS_VPC_ID par l'ID de votre VPC AWS. Exemple : vpc-1234567890abc.

    • AWS_REGION par la région AWS de votre cluster d'utilisateur. Exemple : us-east-1.

    Pour plus d'informations sur cette configuration, consultez la section alb-ingress-controller dans le dépôt GitHub de aws-alb-ingress-controller.

  2. Appliquez le fichier manifeste à votre cluster :

    env HTTP_PROXY=http://localhost:8118 \
      kubectl apply -f aws-alb-ingress-controller.yaml
    

Créer un ALB

Dans cette section, vous allez créer un 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 HTTP_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 HTTP_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 ADB dans un navigateur. Par exemple :http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Le jeu 2048 s'affiche.