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 dei bilanciatori del carico.

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

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 degli ALB.
Crea un ruolo AWS che consenta al controller ALB di accedere 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 e implementare un'altra configurazione ALB.

crea un bilanciatore del carico delle applicazioni

Tagga le subnet per l'ALB

Prima di creare un ALB, devi indicare ad AWS in quali sottoreti eseguirlo. Il metodo consueto consiste nel taggare la sottorete con un tag che la identifica 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 Etichettare le subnet del bilanciatore del carico del servizio.

Per annotare l'oggetto Ingress con un elenco di sottoreti, 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 o nomi di sottoreti, ad esempio subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef.

Crea autorizzazioni IAM AWS

Scarica il criterio IAM per il controller AWS Load Balancer. Questo criterio elenca 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, sostituire 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 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 il seguente comando:

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

Trova l'ID VPC del tuo cluster eseguendo il seguente 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

Per trovare la regione AWS del tuo cluster, esegui il seguente 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 tuo cluster, ad esempio bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
AWS_VPC_ID: l'ID della tua 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 seguente comando:
```
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 indica 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 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 Kubernetes. Il deployment è 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 del fatto 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 il seguente comando:

kubectl delete -f 2048.yaml

Passaggi successivi

Scopri di più sulle annotazioni di ingressi
Consulta la documentazione di AWS Load Balancer Controller.

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