Questa documentazione si riferisce alla versione attuale di GKE su AWS, rilasciata a novembre 2021. Consulta le Note di rilascio per ulteriori informazioni.

Questa pagina è stata tradotta dall'API Cloud Translation.

configura un bilanciatore del carico HTTP

Questa pagina mostra come configurare un Bilanciatore del carico delle applicazioni (ALB) AWS.

Per ulteriori informazioni sugli altri tipi di bilanciatori del carico supportati da GKE su AWS, consulta Panoramica del bilanciatore del carico.

Prima di iniziare

Prima che GKE su AWS possa creare un ALB, devi:

Crea un cluster GKE su AWS e configura l'accesso con kubectl.
Registra il provider OIDC del cluster con AWS.

Panoramica

La creazione della prima ALB in un cluster prevede i seguenti passaggi:

Identifica e tagga o annota le subnet all'interno del tuo VPC in cui vuoi eseguire il provisioning degli ALB.
Crea un ruolo AWS che consenta al controller ALB di accedere alle risorse AWS.
Installa l'app aws-load-balancer-controller open source.
Creazione e deployment di una configurazione ALB.

Per creare ALB successive, devi solo creare ed eseguire il deployment di un'altra configurazione ALB.

Crea un bilanciatore del carico delle applicazioni

Applica un tagging alle subnet per ALB

Prima di creare un componente ALB, devi indicare ad AWS in quali subnet eseguirlo. Il metodo abituale è codificare la subnet con un tag che la identifichi come disponibile per il processo di rilevamento automatico. In alternativa, puoi aggiungere un'annotazione all'oggetto Ingress per elencare esplicitamente le subnet in cui eseguirlo.

Per contrassegnare le subnet selezionate come disponibili per il rilevamento automatico, vedi Codificare le subnet del bilanciatore del carico del servizio.

Per annotare l'oggetto Ingress con un elenco di subnet, aggiungi un'annotazione denominata alb.ingress.kubernetes.io/subnets all'oggetto Kubernetes Ingress. Imposta il valore dell'annotazione su un elenco separato da virgole di ID o nomi di subnet, ad esempio subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef.

Crea autorizzazioni AWS IAM

Scarica il criterio IAM per il controller AWS Load Balancer. Questo criterio indica le autorizzazioni necessarie per il funzionamento del controller del bilanciatore del carico. Puoi consultare le norme su GitHub. Questo comando salva il criterio in un file denominato iam_policy.json.

  curl -Lo iam_policy.json \
    https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.4.4/docs/install/iam_policy.json

Utilizza questo file per creare un criterio IAM denominato AWSLoadBalancerControllerIAMPolicy:

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

Concedi l'accesso al bilanciatore del carico

Crea un ruolo AWS IAM per l'account di servizio del controller seguendo le istruzioni riportate in Creare un ruolo AWS IAM. In queste istruzioni, sostituisci quanto segue:

AWS_POLICY_ARN: l'ARN dell'AWSLoadBalancerControllerIAPolicy creato nel passaggio precedente
KSA_NAME: "aws-load-balancer-controller"
K8S_NAMESPACE: "kube-system"
AWS_ROLE_NAME: "AWSLBControllerRole"

Per recuperare l'ARN del criterio, esegui questo comando:

aws iam list-policies \
  --query 'Policies[?PolicyName==`AWSLoadBalancerControllerIAMPolicy`].Arn' \
  --output text

Installa il controller del bilanciatore del carico AWS

Per completare questi passaggi, estrai e salva i seguenti valori. Ti serviranno in un secondo momento.

Trova l'UID del cluster eseguendo questo comando:

  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(uid)"

Trova l'ID VPC del cluster eseguendo questo comando:

  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(networking.vpcId)"

Trova l'ARN del ruolo denominato AWSLBControllerRole eseguendo questo comando:

aws iam get-role --role-name AWSLBControllerRole --query Role.Arn --output text

Trova la regione AWS del tuo cluster eseguendo questo comando:

gcloud container aws clusters describe CLUSTER_NAME \
  --location GOOGLE_CLOUD_LOCATION \
  --format "value(awsRegion)"

Sostituisci:

GOOGLE_CLOUD_LOCATION con il nome della regione Google associata al cluster
CLUSTER_NAME con il nome del cluster

Installa cert-manager con il seguente comando:

kubectl apply \
  --validate=false \
  -f https://github.com/jetstack/cert-manager/releases/download/v1.10.0/cert-manager.yaml

Scarica il manifest per aws-load-balancer-controller e salvalo nel file locale v2_4_4_full.yaml con il seguente comando:

curl -Lo v2_4_4_full.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.4.4/v2_4_4_full.yaml

Modifica il file v2_4_4_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.4
        env:
        - name: AWS_ROLE_ARN
          value: AWS_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.
AWS_ROLE_ARN: l'ARN del ruolo denominato AWSLBControllerRole
AWS_REGION: la regione AWS del cluster, ad esempio us-east-1

Applica il manifest modificato al cluster con il comando seguente:
```
kubectl apply -f v2_4_4_full.yaml
```
Conferma che il controller del bilanciatore del carico sia in esecuzione con il seguente comando:
```
kubectl get deployment -n kube-system aws-load-balancer-controller
```
L'output dovrebbe essere simile al seguente, dimostrando che il deployment aws-load-balancer-controller è disponibile.
```
NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   1/1     1            1           51s
```

Crea un ALB di esempio

Questa sezione mostra come creare un'ALB di esempio che pubblichi 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 ALB in entrata.

apiVersion: v1
kind: Namespace
metadata:
  name: game-2048
---
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: game-2048
  name: deployment-2048
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: app-2048
  replicas: 5
  template:
    metadata:
      labels:
        app.kubernetes.io/name: app-2048
    spec:
      containers:
      - image: alexwhen/docker-2048
        imagePullPolicy: Always
        name: app-2048
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  namespace: game-2048
  name: service-2048
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  type: NodePort
  selector:
    app.kubernetes.io/name: app-2048
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: game-2048
  name: ingress-2048
  annotations:
    alb.ingress.kubernetes.io/scheme: internet-facing
spec:
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: service-2048
                port:
                  number: 80

Applica la configurazione al cluster con il comando seguente:
```
kubectl apply -f 2048.yaml
```

Controlla lo stato della risorsa Ingress con il comando seguente:

kubectl get ingress -n game-2048 ingress-2048

L'output comando è simile al seguente. La colonna ADDRESS contiene l'endpoint della risorsa Ingress.

 NAME           CLASS    HOSTS   ADDRESS                                                                   PORTS   AGE
 ingress-2048   <none>   *       k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com   80      2m19s
 ```

Vai all'endpoint ALB in un browser, ad esempio: http://k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com. Viene visualizzato il gioco 2048, che indica che il deployment e la configurazione del bilanciatore del carico ALB sono andati a buon fine.

esegui la pulizia

Per rimuovere l'ALB di esempio e il deployment creati nel passaggio precedente, elimina il manifest con il seguente comando:

kubectl delete -f 2048.yaml

Passaggi successivi

Scopri di più sulle annotazioni Ingress
Scopri di più sulla documentazione relativa al controller del bilanciatore del carico AWS.