Configurare Ingress per i bilanciatori del carico delle applicazioni esterni

Questa pagina mostra come configurare un bilanciatore del carico delle applicazioni esterno creando un oggetto Kubernetes Ingress.

Prima di leggere questa pagina, assicurati di avere familiarità con i concetti di networking GKE.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

• Attiva l'API Google Kubernetes Engine.
Attiva l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializzala. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.

Attiva il componente aggiuntivo HttpLoadBalancing

Il cluster deve avere il componente aggiuntivo HttpLoadBalancing abilitato. Questo componente aggiuntivo è attivato per impostazione predefinita. Nei cluster Autopilot, non puoi disattivare questo componente aggiuntivo.

Puoi attivare il componente aggiuntivo HttpLoadBalancing utilizzando la console Google Cloud o Google Cloud CLI.

gcloud container clusters update CLUSTER_NAME --update-addons=HttpLoadBalancing=ENABLED

Crea un indirizzo IP statico

Un bilanciatore del carico delle applicazioni esterno fornisce un indirizzo IP stabile che puoi utilizzare per instradare le richieste a uno o più servizi. Se vuoi un indirizzo IP permanente, devi prenotare un indirizzo IP esterno statico globale prima di creare un Ingress.

Se modifichi un Ingress esistente in modo che utilizzi un indirizzo IP statico anziché un indirizzo IP temporaneo, GKE potrebbe modificare l'indirizzo IP del bilanciatore del carico quando ricrea la regola di forwarding del bilanciatore del carico.

Crea un bilanciatore del carico delle applicazioni esterno

In questo esercizio configurerai un bilanciatore del carico delle applicazioni esterno per instradare le richieste a servizi diversi in base al percorso dell'URL.

Per seguire le indicazioni dettagliate per questa attività direttamente nella Google Cloud console, fai clic su Procedura guidata:

Procedura guidata

Crea deployment e servizi

Crea due deployment con servizi denominati hello-world-1 e hello-world-2:

1. Salva il seguente manifest come hello-world-deployment-1.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: hello-world-deployment-1
   spec:
     selector:
       matchLabels:
         greeting: hello
         version: one
     replicas: 3
     template:
       metadata:
         labels:
           greeting: hello
           version: one
       spec:
         containers:
         - name: hello-app-1
           image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0"
           env:
           - name: "PORT"
             value: "50000"
   

   Questo manifest descrive un deployment di esempio con tre repliche.

2. Applica il manifest al cluster:

   kubectl apply -f hello-world-deployment-1.yaml
   

3. Salva il seguente manifest come hello-world-service-1.yaml:

   apiVersion: v1
   kind: Service
   metadata:
     name: hello-world-1
   spec:
     type: NodePort
     selector:
       greeting: hello
       version: one
     ports:
     - protocol: TCP
       port: 60000
       targetPort: 50000
   

   Questo manifest descrive un servizio con le seguenti proprietà:

   • Qualsiasi pod con l'etichetta greeting: hello e l'etichetta version: one è membro del servizio.
   • GKE inoltra le richieste inviate al servizio sulla porta TCP 60000 a uno dei pod membri sulla porta TCP 50000.
   • Il tipo di servizio è NodePort, che è obbligatorio a meno che non utilizzi il bilanciamento del carico nativo del container. Se utilizzi il bilanciamento del carico nativo del container, non ci sono limitazioni al tipo di servizio. Consigliamo di utilizzare type: ClusterIP.

4. Applica il manifest al cluster:

   kubectl apply -f hello-world-service-1.yaml
   

5. Salva il seguente manifest come hello-world-deployment-2.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: hello-world-deployment-2
   spec:
     selector:
       matchLabels:
         greeting: hello
         version: two
     replicas: 3
     template:
       metadata:
         labels:
           greeting: hello
           version: two
       spec:
         containers:
         - name: hello-app-2
           image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
           env:
           - name: "PORT"
             value: "8080"
   

   Questo manifest descrive un deployment di esempio con tre repliche.

6. Applica il manifest al cluster:

   kubectl apply -f hello-world-deployment-2.yaml
   

7. Salva il seguente manifest come hello-world-service-2.yaml:

   apiVersion: v1
   kind: Service
   metadata:
     name: hello-world-2
   spec:
     type: NodePort
     selector:
       greeting: hello
       version: two
     ports:
     - protocol: TCP
       port: 80
       targetPort: 8080
   

   Questo manifest descrive un servizio con le seguenti proprietà:

   • Qualsiasi pod con l'etichetta greeting: hello e l'etichetta version: two è membro del servizio.
   • GKE inoltra le richieste inviate al servizio sulla porta TCP 80 a uno dei pod membri sulla porta TCP 8080.

8. Applica il manifest al cluster:

   kubectl apply -f hello-world-service-2.yaml
   

Crea una risorsa Ingress

Crea un Ingress che specifichi le regole per l'instradamento delle richieste in base al percorso dell'URL nella richiesta. Quando crei Ingress, il controller Ingress di GKE crea e configura un bilanciatore del carico delle applicazioni esterno.

1. Salva il seguente manifest come my-ingress.yaml:

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: my-ingress
     annotations:
       # If the class annotation is not specified it defaults to "gce".
       kubernetes.io/ingress.class: "gce"
   spec:
     rules:
     - http:
         paths:
         - path: /*
           pathType: ImplementationSpecific
           backend:
             service:
               name: hello-world-1
               port:
                 number: 60000
         - path: /v2
           pathType: ImplementationSpecific
           backend:
             service:
               name: hello-world-2
               port:
                 number: 80
   

   Questo manifest descrive un Ingress con le seguenti proprietà:

   • Esistono due classi GKE Ingress. Per specificare una classe Ingress, devi utilizzare l'annotazione kubernetes.io/ingress.class. Non puoi specificare un GKE Ingress utilizzando spec.ingressClassName.

   • La classe gce esegue il deployment di un bilanciatore del carico delle applicazioni esterno.

   • La classe gce-internal esegue il deployment di un bilanciatore del carico delle applicazioni interno.

   • Quando esegui il deployment di una risorsa Ingress senza le annotazioni spec.ingressClassName e kubernetes.io/ingress.class, GKE crea un bilanciatore del carico delle applicazioni esterno. Questo è lo stesso comportamento che si verifica se specifichi l'annotazione kubernetes.io/ingress.class: gce. Per maggiori informazioni, vedi Comportamento del controller Ingress di GKE.

   • GKE crea un Google Cloud servizio di backend per ogni backend.service. Ciascuno dei servizi di backend corrisponde a un servizio Kubernetes e ogni servizio di backend deve fare riferimento a un Google Cloud controllo di integrità. Questo controllo di integrità è diverso da un probe di attività o di idoneità di Kubernetes perché viene implementato al di fuori del cluster. Per saperne di più, consulta Controlli di integrità.

   • Quando un client invia una richiesta al bilanciatore del carico con percorso dell'URL /, GKE inoltra la richiesta al servizio hello-world-1 sulla porta 60000. Quando un client invia una richiesta al bilanciatore del carico utilizzando il percorso dell'URL /v2, GKE inoltra la richiesta al servizio hello-world-2 sulla porta 80. Per ulteriori informazioni sulle proprietà path e pathType, consulta Percorsi URL.

2. Applica il manifest al cluster:

   kubectl apply -f my-ingress.yaml
   

testa il bilanciatore del carico delle applicazioni esterno

Attendi circa cinque minuti per la configurazione del bilanciatore del carico, quindi testa il bilanciatore del carico delle applicazioni esterno:

1. Visualizza l'ingresso:

   kubectl get ingress my-ingress --output yaml
   

   L'output mostra l'indirizzo IP del bilanciatore del carico delle applicazioni esterno:

   status:
     loadBalancer:
       ingress:
       - ip: 203.0.113.1
   

2. Testa il percorso /:

   curl LOAD_BALANCER_IP_ADDRESS/
   

   Sostituisci LOAD_BALANCER_IP_ADDRESS con l'indirizzo IP esterno del bilanciatore del carico.

   L'output è simile al seguente:

   Hello, world!
   Version: 1.0.0
   Hostname: ...
   

   Se l'output include un errore 404, attendi qualche minuto.

3. Testa il percorso /v2:

   curl load-balancer-ip/v2
   

   L'output è simile al seguente:

   Hello, world!
   Version: 2.0.0
   Hostname: ...
   

Come funziona Ingress per il bilanciamento del carico esterno

Un bilanciatore del carico delle applicazioni esterno funge da proxy tra i client e l'applicazione. Se vuoi accettare richieste HTTPS dai tuoi client, il bilanciatore del carico deve avere un certificato per poter dimostrare la sua identità ai tuoi client. Il bilanciatore del carico deve avere anche una chiave privata per completare l'handshake HTTPS. Per ulteriori informazioni, vedi:

• Configurazione di HTTPS (TLS) tra il client e il bilanciatore del carico.
• Utilizzo di più certificati SSL nel bilanciamento del carico HTTPS con Ingress.

Percorsi URL

L'unico carattere jolly supportato per il campo path di un Ingress è il carattere *. Il carattere * deve seguire una barra (/) e deve essere l'ultimo carattere nel pattern. Ad esempio, /*, /foo/* e /foo/bar/* sono pattern validi, mentre *, /foo/bar* e /foo/*/bar non lo sono.

Un pattern più specifico ha la precedenza su un pattern meno specifico. Se hai sia /foo/* che /foo/bar/*, /foo/bar/bat viene considerato corrispondente a /foo/bar/*. Per saperne di più sulle limitazioni del percorso e sulla corrispondenza dei pattern, consulta la documentazione sulle mappe URL.

Per i cluster GKE che eseguono versioni precedenti alla 1.21.3-gke.1600, l'unico valore supportato per il campo pathType è ImplementationSpecific. Per i cluster che eseguono la versione 1.21.3-gke.1600 o successive, sono supportati anche i valori Prefix e Exact per pathType.

Disattivazione di HTTP

Se vuoi che tutto il traffico tra il client e il bilanciatore del carico utilizzi HTTPS, puoi disattivare HTTP. Per saperne di più, consulta la sezione Disattivazione di HTTP.

HTTPS tra il bilanciatore del carico e l'applicazione

Se la tua applicazione, in esecuzione in un pod GKE, è in grado di ricevere richieste HTTPS, puoi configurare il bilanciatore del carico in modo che utilizzi HTTPS quando inoltra le richieste alla tua applicazione. Per ulteriori informazioni, consulta HTTPS (TLS) tra il bilanciatore del carico e la tua applicazione.

HTTP/2 tra client e bilanciatore del carico

I client possono utilizzare HTTP/2 per inviare richieste al bilanciatore del carico. Non è richiesta alcuna configurazione.

HTTP/2 tra il bilanciatore del carico e l'applicazione

Se la tua applicazione, in esecuzione in un pod GKE, è in grado di ricevere richieste HTTP/2, puoi configurare il bilanciatore del carico in modo che utilizzi HTTP/2 quando inoltra le richieste alla tua applicazione. Per saperne di più, consulta HTTP/2 per il bilanciamento del carico con Ingress.

Gruppi di endpoint di rete

Se il cluster supporta il bilanciamento del carico nativo del container, ti consigliamo di utilizzare i gruppi di endpoint di rete (NEG). Per i cluster GKE 1.17 e versioni successive e in determinate condizioni, il bilanciamento del carico nativo dei container è predefinito e non richiede un'annotazione Service cloud.google.com/neg: '{"ingress": true}' esplicita.

VPC condiviso

Se il cluster GKE in cui stai eseguendo il deployment delle risorse Ingress si trova in un progetto di servizio e vuoi che il piano di controllo GKE gestisca le risorse firewall nel progetto host, al service account GKE del progetto di servizio devono essere concesse le autorizzazioni IAM appropriate nel progetto host, come descritto in Gestione delle risorse firewall per i cluster con VPC condiviso. In questo modo, il controller Ingress può creare regole firewall per consentire sia il traffico in entrata sia il traffico per i controlli di integrità Google Cloud .

Di seguito è riportato un esempio di evento che potrebbe essere presente nei log delle risorse Ingress. Questo errore si verifica quando il controller Ingress non è in grado di creare una regola firewall per consentire il traffico in entrata per i controlli di integrità Google Cloud se le autorizzazioni non sono configurate correttamente.

Firewall change required by security admin: `gcloud compute firewall-rules update <RULE_NAME> --description "GCE L7 firewall rule" --allow tcp:<PORT> --source-ranges 130.211.0.0/22,35.191.0.0/16 --target-tags <TARGET_TAG> --project <HOST_PROJECT>

Se preferisci eseguire il provisioning manuale delle regole firewall dal progetto host, puoi disattivare gli eventi firewallXPNError aggiungendo l'annotazione networking.gke.io/suppress-firewall-xpn-error: "true" alla risorsa Ingress.

Riepilogo delle annotazioni Ingress esterne

Annotazioni Ingress

Annotazioni di servizio relative a Ingress

Passaggi successivi

• Leggi una panoramica concettuale di Ingress per i bilanciatori del carico delle applicazioni esterni in GKE.

• Segui il tutorial su Configurazione di un bilanciatore del carico delle applicazioni esterno con Ingress.

• Leggi una panoramica concettuale dei servizi in GKE.

• Implementa un Ingress esterno di base.