Produk yang dijelaskan dalam dokumentasi ini, Cluster Anthos di AWS (generasi sebelumnya), kini berada dalam mode pemeliharaan. Semua penginstalan baru harus menggunakan produk generasi saat ini, cluster Anthos di AWS.

Halaman ini diterjemahkan oleh Cloud Translation API.

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:

Lengkapi Prasyarat.

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.

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

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

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.
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.
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"
  }
}
```
Perhatian: Anda tidak dapat mengambil kunci rahasia setelah tahap ini. Simpan kunci tersebut untuk digunakan nanti.
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
```
Catatan: Anda juga memerlukan kunci akses dan kunci rahasia di bagian berikut.
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.

Penting: Pastikan konteks Anda ditetapkan ke cluster pengguna tempat ALB ingin diaktifkan.
```
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:

cert-manager Jetstack guna membuat dan mengelola sertifikat TLS untuk resource ALB cluster Anda.
Pengontrol Load Balancer AWS untuk menyediakan dan mengelola ALB.

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

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

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

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.

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

Gunakan kubectl untuk menerapkan konfigurasi ke cluster Anda.

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

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

Buka endpoint ALB di browser. Misalnya: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Game 2048 muncul.

Langkah selanjutnya

Baca dokumentasi pengontrol Ingress ALB.