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

Questa pagina è stata tradotta dall'API Cloud Translation.

Creazione di un bilanciatore del carico dell'applicazione (ALB)

Questo argomento mostra come configurare un bilanciatore del carico delle applicazioni (ALB) AWS con GKE su AWS.

Prima di iniziare

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

Completa i prerequisiti.

Disporre delle autorizzazioni per creare criteri, ruoli e utenti AWS 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 contesto al cluster utente.
```
cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
```
Sostituisci CLUSTER_NAME con il nome del tuo cluster utente.
Installa lo strumento a riga di comando curl o uno strumento simile.

Tagging delle subnet

GKE su AWS richiede tag in subnet che contengono endpoint ALB. GKE su AWS applica automaticamente il tag a tutte le subnet specificate nel campo spec.Networking.ServiceLoadBalancerSubnetIDs della risorsa AWSCluster.

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

Configura ALB su GKE su AWS

Prima di poter creare un ALB, devi configurare GKE su AWS impostando le autorizzazioni AWS IAM e fornendo le chiavi di accesso.

Crea autorizzazioni AWS IAM

Per creare un ALB per il cluster utente, devi configurare un utente AWS IAM con le autorizzazioni per creare e utilizzare ALB.

Scarica un criterio IAM per il controller Ingress ALB. Puoi consultare 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 l'Amazon Resource Name (ARN) del criterio IAM. Salva l'ARN per un utilizzo futuro.

Concedi l'accesso al bilanciatore del carico

In questa sezione, assocerai il criterio relativo agli utenti a un utente AWS IAM 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 controller Ingress ALB.
- ALB_IAM_POLICY_ARN con l'ARN del criterio IAM che hai creato in precedenza.
Crea una chiave di accesso AWS IAM 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: non è possibile recuperare la chiave segreta dopo questo punto. Salva la chiave per utilizzarla in seguito.
Salva la chiave di accesso e la chiave di accesso segreta nelle variabili di ambiente. Utilizzerai questi dati per configurare il cluster utente.
```
ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
```
Nota: sono necessari anche la chiave di accesso e la chiave segreta nella sezione seguente.
Crea un secret nel tuo cluster con la chiave di accesso e la chiave di accesso del secret. Il controller Ingress ALB utilizza questo secret per eseguire l'autenticazione in AWS e gestire ALB.

Importante: assicurati che il 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 Workload Identity

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

Configura il cluster

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

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

Esegui il deployment di cert-manager Jetstack installando il 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 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

Scegli se utilizzi un utente o un ruolo IAM con Workload Identity.

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 durante la creazione di un utente AWS IAM
AWS_SECRET_ACCESS_KEY: la chiave di accesso secret AWS generata durante la creazione di un utente AWS IAM

Ruolo con Workload Identity

Modifica il file v2_4_0_full.yaml e cerca kind: Deployment. Sostituisci l'intero oggetto Deployment con questa 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: l'UID del cluster, ad esempio bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
AWS_VPC_ID: l'ID del VPC AWS, ad esempio vpc-1234567890abc
LB_CONTROLLER_ROLE_ARN: l'ARN del ruolo AWSLBControllerRole
AWS_REGION: la regione 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
```
GKE su AWS installa il controller Ingress ALB.

Creazione di una ALB

In questa sezione creerai un'ALB di esempio che serve 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 Kubernetes. Il deployment è esposto tramite un comando 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 tua risorsa Ingress. La colonna ADDRESS contiene l'endpoint della tua risorsa 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. Ad esempio: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Viene visualizzato il gioco 2048.

Passaggi successivi

Leggi la documentazione sul controller Ingress ALB.