Il prodotto descritto in questa documentazione, Cluster Anthos su AWS (generazione precedente), è ora in modalità di manutenzione. Tutte le nuove installazioni devono utilizzare il prodotto di generazione attuale, Cluster Anthos su AWS.

Creazione di un bilanciatore del carico delle applicazioni (ALB)

Questo argomento mostra come configurare un bilanciatore del carico applicativo AWS (ALB) con cluster Anthos su AWS (GKE su AWS).

Prima di iniziare

Prima di iniziare a utilizzare i cluster Anthos su AWS, assicurati di aver eseguito le seguenti attività:

Completa i Prerequisiti.

Disporre delle autorizzazioni per creare criteri, ruoli e utenti IAM per il bilanciatore del carico.
Installa un servizio di gestione.
Crea un cluster utente. Se utilizzi Workload Identity, crea un cluster utente con Workload Identity.
Dalla directory anthos-aws, utilizza anthos-gke per cambiare il contesto del cluster utente.
```
cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
```
Sostituisci CLUSTER_NAME con il tuo nome cluster utente.
Installa lo strumento a riga di comando curl o uno strumento simile.

Tagging delle subnet

I cluster Anthos su AWS richiedono tag su subnet che contengono endpoint ALB. I cluster Anthos su AWS codificano automaticamente tutte le subnet specificate nel campo spec.Networking.ServiceLoadBalancerSubnetIDs della risorsa AWSCluster.

Se hai installato cluster Anthos su AWS in un VPC esistente o vuoi utilizzare subnet aggiuntive, applica i tag alle subnet in due o più zone di disponibilità AWS.

Configurazione di ALB sui cluster Anthos su AWS

Per poter creare un cluster ALB, devi prima configurare i cluster Anthos su AWS impostando le autorizzazioni IAM di AWS e fornendo chiavi di accesso.

Creazione di autorizzazioni AWS IAM

Per creare un servizio ALB per un tuo cluster utente, devi configurare un utente IAM AWS dotato delle autorizzazioni necessarie per creare e utilizzare il servizio ALB.

Scarica un criterio IAM per il controller ALB Ingress. Puoi rivedere le norme su GitHub.

curl -o iam-policy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.4.0/docs/install/iam_policy.json

Utilizza lo strumento a riga di comando aws per creare un criterio IAM denominato ALBIngressControllerIAMPolicy.
```
aws iam create-policy \
  --policy-name ALBIngressControllerIAMPolicy \
  --policy-document file://iam-policy.json
```
La risposta include il nome di risorsa Amazon (ARN) del criterio IAM. Salva l'ARN per un utilizzo successivo.

Concedi l'accesso al tuo bilanciatore del carico

In questa sezione, associ il criterio utente a un utente IAM AWS o a un ruolo IAM con un'identità del carico di lavoro configurata.

Utente IAM

Utilizza lo strumento aws per creare un utente IAM per il controller Ingress ALB.
```
aws iam create-user \
--user-name ALB_CONTROLLER_USER_NAME
```
Sostituisci ALB_CONTROLLER_USER_NAME con il nome utente che vuoi creare per il controller Ingress ALB.
Allega ALBIngressControllerIAMPolicy al nome utente.
```
aws iam attach-user-policy \
 --user-name ALB_CONTROLLER_USER_NAME \
 --policy-arn ALB_IAM_POLICY_ARN
```
Sostituisci quanto segue:
- ALB_CONTROLLER_USER_NAME con il nome utente che vuoi creare per il tuo controller ALB Ingress.
- ALB_IAM_POLICY_ARN con l'ARN del criterio IAM creato in precedenza.
Crea una chiave di accesso IAM AWS per l'utente del controller ALB Ingress.
```
aws iam create-access-key --user-name ALB_CONTROLLER_USER_NAME
```
Sostituisci ALB_CONTROLLER_USER_NAME con il nome utente che vuoi creare per il controller Ingress ALB.

Lo strumento a riga di comando aws stampa i dettagli della chiave di accesso.
```
{
  "AccessKey": {
    "UserName": ALB_CONTROLLER_USER_NAME
    "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
    "Status": "Active",
    "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
    "CreateDate": "2020-07-23T17:53:58Z"
  }
}
```
Attenzione: dopo questa fase non potrai più recuperare la chiave segreta. Salva la chiave per utilizzarla in seguito.
Salva la chiave di accesso e la chiave di accesso segreta nelle variabili di ambiente. Li utilizzerai per configurare il cluster utenti.
```
ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
```
Nota: sono necessarie anche la chiave di accesso e la chiave segreta nella sezione seguente.
Crea un secret nel cluster con la chiave di accesso e la chiave di accesso segreta. Il controller Ingress ALB utilizza questo secret per eseguire l'autenticazione in AWS e gestire gli ALB.

Importante: assicurati che il tuo contesto sia impostato sul cluster utente su cui vuoi abilitare 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
```

Ruolo con identità del carico di lavoro

Completa i passaggi descritti in Creazione di un cluster utente con Workload Identity. Quando crei un criterio, utilizza l'ARN di ALBIngressControllerIAMPolicy per il valore di EXISTING_AWS_POLICY.

Configura il cluster

Per configurare un servizio ALB, devi installare i seguenti componenti nel tuo cluster utente:

Jetstack cert-manager per generare e gestire i certificati TLS per le tue risorse ALB del cluster.
Il controller del bilanciatore del carico AWS per eseguire il provisioning e la gestione degli ALB.

Esegui il deployment del sistema di gestione certificati Jetstack installando il file manifest da 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

Scarica il file manifest del controller del bilanciatore del carico AWS da 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

Seleziona se utilizzi un utente IAM o un ruolo di identità con carico di lavoro.

Utente IAM

Modifica il file v2_4_0_full.yaml e cerca kind: Deployment. Sostituisci l'oggetto Deployment con questa versione modificata.

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

Sostituisci quanto segue:

AWS_ACCESS_KEY_ID: la chiave di accesso AWS generata quando hai creato un utente IAM AWS
AWS_SECRET_ACCESS_KEY: la chiave di accesso segreta di AWS generata durante la creazione di un utente AWS IAM.

Ruolo con identità del carico di lavoro

Modifica il file v2_4_0_full.yaml e cerca kind: Deployment. Sostituisci l'intero oggetto Deployment con la versione modificata:

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

Sostituisci quanto segue:

CLUSTER_UID: UID del cluster, ad esempio bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
AWS_VPC_ID: l'ID del tuo VPC AWS, ad esempio vpc-1234567890abc
LB_CONTROLLER_ROLE_ARN: ARN del ruolo AWSLBControllerRole
AWS_REGION: area geografica AWS del cluster, ad esempio us-east-1

Applica il controller al cluster.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f v2_4_0_full.yaml
```
I cluster Anthos su AWS installano il controller Ingress ALB.

Creazione di un operatore ALB

In questa sezione, crei un ALB di esempio che pubblica un remake del gioco 2048.

Copia la seguente configurazione YAML in un file denominato 2048.yaml. La configurazione crea uno spazio dei nomi, un servizio e un deployment di Kubernetes. Il deployment viene esposto utilizzando un 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

Utilizza kubectl per applicare la configurazione al cluster.

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

Usa kubectl per controllare lo stato della risorsa Ingress.

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

Viene visualizzato lo stato della risorsa Ingress. La colonna ADDRESS contiene l'endpoint di Ingress.

NAME           HOSTS   ADDRESS                                                             PORTS   AGE
2048-ingress   *       123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com   80      2m19s

Vai all'endpoint ALB in un browser. Esempio: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Viene visualizzato il gioco 2048.

Passaggi successivi

Leggi la documentazione di ALB Ingress controller.