Il prodotto descritto da questa documentazione, GKE su AWS, è ora in modalità di manutenzione e verrà chiuso il 17 marzo 2027.

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 saperne di più sugli altri tipi di bilanciatori del carico supportati da GKE su AWS, consulta la Panoramica del bilanciatore del carico.

Questa pagina è rivolta agli specialisti di networking che vogliono installare, configurare e supportare le apparecchiature di rete. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti di Google Cloud , consulta Ruoli e attività comuni degli utenti GKE.

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 del primo ALB in un cluster prevede i seguenti passaggi:

Identifica e tagga o annota le subnet all'interno del VPC in cui vuoi eseguire il provisioning dei bilanciatori del carico delle applicazioni.
Crea un ruolo AWS che conceda al controller ALB l'accesso alle risorse AWS.
Installa aws-load-balancer-controller open source.
Crea ed esegui il deployment di una configurazione ALB.

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

crea un bilanciatore del carico delle applicazioni

Tagga le subnet per il tuo ALB

Prima di creare un ALB, devi indicare ad AWS in quali subnet eseguirlo. Il metodo più comune consiste nell'assegnare alla subnet 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 deve essere eseguito.

Per taggare le subnet selezionate come disponibili per il rilevamento automatico, consulta Tagga 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 Ingress di Kubernetes. Imposta il valore dell'annotazione su un elenco separato da virgole di ID subnet o nomi di subnet, ad esempio subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef.

Crea autorizzazioni IAM AWS

Scarica il criterio IAM per AWS Load Balancer Controller. Questo criterio elenca le autorizzazioni necessarie per il funzionamento del controller del bilanciamento 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

Concedere l'accesso al bilanciatore del carico

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

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

Per recuperare l'ARN della policy, 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 il seguente 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 tuo 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 tuo VPC AWS, ad esempio vpc-1234567890abc.
AWS_ROLE_ARN: l'ARN del ruolo denominato AWSLBControllerRole
AWS_REGION: la regione AWS del tuo cluster, ad esempio us-east-1

Applica il manifest modificato al cluster con il comando seguente:
```
kubectl apply -f v2_4_4_full.yaml
```

Verifica 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, che mostra che l'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 pubblica un remake del gioco 2048.

Copia la seguente configurazione YAML in un file denominato 2048.yaml. La configurazione crea un servizio, uno spazio dei nomi e un deployment Kubernetes. Il deployment viene esposto tramite un ALB Ingress.

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 seguente comando:
```
kubectl apply -f 2048.yaml
```

Controlla lo stato della risorsa Ingress con il seguente comando:

kubectl get ingress -n game-2048 ingress-2048

L'output del 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, a dimostrazione che hai eseguito il deployment e configurato correttamente il bilanciatore del carico ALB.

Pulizia

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

kubectl delete -f 2048.yaml

Passaggi successivi

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

configura un bilanciatore del carico HTTP Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.