Membuat load balancer aplikasi (ALB)

Topik ini menunjukkan cara menyiapkan Load Balancer Aplikasi (ALB) AWS dengan GKE di AWS.

Sebelum memulai

Sebelum mulai menggunakan GKE di AWS, pastikan Anda telah melakukan tugas berikut:

  • Memiliki izin untuk membuat kebijakan, peran, dan pengguna IAM AWS untuk load balancer.
  • Instal layanan pengelolaan.
  • Buat cluster pengguna. Jika Anda menggunakan identitas workload, Buat cluster pengguna dengan workload identity.
  • Dari direktori anthos-aws, gunakan anthos-gke untuk mengalihkan konteks ke cluster pengguna.
    cd anthos-aws
    env HTTPS_PROXY=http://localhost:8118 \
      anthos-gke aws clusters get-credentials CLUSTER_NAME
    Ganti CLUSTER_NAME dengan nama cluster pengguna Anda.
  • Instal alat command line curl atau alat yang serupa.

Memberi tag pada subnet

GKE di AWS memerlukan tag pada subnet yang berisi endpoint ALB. GKE di AWS akan otomatis memberi tag pada semua subnet yang ditentukan di kolom spec.Networking.ServiceLoadBalancerSubnetIDs dari resource AWSCluster.

Jika Anda telah menginstal GKE di AWS ke VPC yang ada, atau ingin menggunakan subnet tambahan, terapkan tag ke subnet di dua atau lebih zona ketersediaan AWS.

Menyiapkan ALB di GKE di AWS

Agar dapat membuat ALB, Anda harus mengonfigurasi GKE di AWS dengan menyiapkan izin IAM AWS dan menyediakan kunci akses.

Membuat izin IAM AWS

Guna membuat ALB untuk cluster pengguna, Anda harus menyiapkan pengguna IAM AWS dengan izin untuk membuat dan mengoperasikan ALB.

  1. Download kebijakan IAM untuk Pengontrol Ingress ALB. Anda dapat meninjau kebijakan ini di 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. Gunakan alat command line aws untuk membuat kebijakan IAM bernama ALBIngressControllerIAMPolicy.

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

    Respons tersebut mencakup Amazon Resource Name (ARN) dari kebijakan IAM. Simpan ARN untuk digunakan nanti.

Memberikan akses ke load balancer

Di bagian ini, Anda akan mengaitkan kebijakan pengguna dengan pengguna IAM AWS, atau dengan peran IAM yang memiliki identitas workload terkonfigurasi.

Pengguna IAM

  1. Gunakan alat aws untuk membuat pengguna IAM untuk pengontrol Ingress ALB.

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

    Ganti ALB_CONTROLLER_USER_NAME dengan nama pengguna yang ingin Anda buat untuk pengontrol ALB Ingress.

  2. Lampirkan ALBIngressControllerIAMPolicy ke nama pengguna.

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

    Ganti kode berikut:

    • ALB_CONTROLLER_USER_NAME dengan nama pengguna yang ingin Anda buat untuk pengontrol ALB Ingress.
    • ALB_IAM_POLICY_ARN dengan ARN kebijakan IAM yang Anda buat sebelumnya.
  3. Membuat kunci akses IAM AWS untuk pengguna pengontrol ALB Ingress.

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

    Ganti ALB_CONTROLLER_USER_NAME dengan nama pengguna yang ingin Anda buat untuk pengontrol ALB Ingress.

    Alat command line aws mencetak detail kunci akses.

    {
      "AccessKey": {
        "UserName": ALB_CONTROLLER_USER_NAME
        "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
        "Status": "Active",
        "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
        "CreateDate": "2020-07-23T17:53:58Z"
      }
    }
    
  4. Simpan kunci akses dan kunci akses rahasia ke dalam variabel lingkungan. Anda akan menggunakannya untuk mengonfigurasi cluster pengguna.

    ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
    ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
    
  5. Buat Secret di cluster Anda dengan kunci akses dan kunci akses secret. Pengontrol Ingress ALB menggunakan Rahasia ini untuk melakukan autentikasi ke AWS dan mengelola 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
    

Peran dengan workload identity

Selesaikan langkah-langkah dalam Membuat cluster pengguna dengan workload identity. Saat Anda membuat kebijakan, gunakan ARN ALBIngressControllerIAMPolicy untuk nilai EXISTING_AWS_POLICY.

Konfigurasi cluster Anda

Untuk mengonfigurasi ALB, Anda harus menginstal komponen berikut di cluster pengguna:

  1. Deploy pengelola sertifikat Jetstack dengan menginstal manifes dari 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. Download manifes Pengontrol Load Balancer AWS dari 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. Pilih apakah Anda menggunakan Pengguna atau Peran IAM dengan workload identity.

    Pengguna IAM

    Edit file v2_4_0_full.yaml dan telusuri kind: Deployment. Ganti objek Deployment dengan versi yang telah dimodifikasi ini.

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

    Ganti kode berikut:

    • AWS_ACCESS_KEY_ID: kunci akses AWS yang dihasilkan saat Anda membuat pengguna IAM AWS
    • AWS_SECRET_ACCESS_KEY: kunci akses rahasia AWS yang dihasilkan saat Anda membuat pengguna AWS IAM

    Peran dengan workload identity

    Edit file v2_4_0_full.yaml dan telusuri kind: Deployment. Ganti seluruh objek Deployment dengan versi yang telah dimodifikasi ini:

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

    Ganti kode berikut:

    • CLUSTER_UID: UID cluster Anda— misalnya, bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
    • AWS_VPC_ID: ID VPC AWS Anda— misalnya, vpc-1234567890abc
    • LB_CONTROLLER_ROLE_ARN: ARN peran AWSLBControllerRole
    • AWS_REGION: region AWS cluster Anda— misalnya, us-east-1
  4. Terapkan pengontrol ke cluster Anda.

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

    GKE di AWS menginstal pengontrol ALB Ingress.

Membuat ALB

Di bagian ini, Anda akan membuat contoh ALB yang menayangkan remake dari game 2048.

  1. Salin konfigurasi YAML berikut ke dalam file bernama 2048.yaml. Konfigurasi akan membuat Namespace, Layanan, dan Deployment Kubernetes. Deployment diekspos menggunakan 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. Gunakan kubectl untuk menerapkan konfigurasi ke cluster Anda.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f 2048.yaml
    
  3. Gunakan kubectl untuk memeriksa status resource Ingress.

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

    Status Ingress Anda akan muncul. Kolom ADDRESS berisi endpoint Ingress Anda.

    NAME           HOSTS   ADDRESS                                                             PORTS   AGE
    2048-ingress   *       123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com   80      2m19s
    
  4. Buka endpoint ALB di browser. Misalnya: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Game 2048 muncul.

Langkah selanjutnya