Questa pagina mostra come configurare un Application Load Balancer esterno creando un oggetto Kubernetes Ingress.
Prima di leggere questa pagina, dovresti acquisire familiarità con i concetti di networking di GKE.
Prima di iniziare
Prima di iniziare, assicurati di aver eseguito le seguenti attività:
- Abilita l'API Google Kubernetes Engine. Abilita l'API Google Kubernetes Engine
- Se vuoi utilizzare Google Cloud CLI per questa attività, installa e initialize gcloud CLI. Se hai già installato gcloud CLI, scarica la versione più recente eseguendo
gcloud components update
.
Attiva il componente aggiuntivo HttpLoadBalancing
Nel cluster deve essere abilitato il componente aggiuntivo HttpLoadBalancing
. Questo componente aggiuntivo è
attivato per impostazione predefinita. Nei cluster Autopilot, non puoi disabilitare questo componente aggiuntivo.
Puoi abilitare il componente aggiuntivo HttpLoadBalancing
utilizzando la console Google Cloud o Google Cloud CLI.
Console
Vai alla pagina Google Kubernetes Engine nella console Google Cloud.
Fai clic sul nome del cluster da modificare.
In Networking, nel campo Bilanciamento del carico HTTP, fai clic su edit Modifica bilanciamento del carico HTTP.
Seleziona la casella di controllo Abilita il bilanciamento del carico HTTP.
Fai clic su Salva modifiche.
gcloud
gcloud container clusters update CLUSTER_NAME --update-addons=HttpLoadBalancing=ENABLED
Sostituisci CLUSTER_NAME
con il nome del cluster.
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 una risorsa Ingress.
Se modifichi una risorsa Ingress esistente in modo da utilizzare un indirizzo IP statico anziché un indirizzo IP temporaneo, GKE potrebbe modificare l'indirizzo IP del bilanciatore del carico quando GKE 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 console Google Cloud, fai clic su Aiuto:
Crea deployment e servizi
Crea due deployment con servizi denominati hello-world-1
e hello-world-2
:
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.
Applica il manifest al cluster:
kubectl apply -f hello-world-deployment-1.yaml
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 sia l'etichetta
greeting: hello
sia l'etichettaversion: one
fa parte del servizio. - GKE inoltra le richieste inviate al servizio sulla porta TCP 60000 a uno dei pod membro 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 sono previste limitazioni sul tipo di servizio. Si consiglia di utilizzaretype: ClusterIP
.
- Qualsiasi pod con sia l'etichetta
Applica il manifest al cluster:
kubectl apply -f hello-world-service-1.yaml
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.
Applica il manifest al cluster:
kubectl apply -f hello-world-deployment-2.yaml
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 sia l'etichetta
greeting: hello
sia l'etichettaversion: two
fa parte del servizio. - GKE inoltra le richieste inviate al servizio sulla porta TCP 80 a uno dei pod membro sulla porta TCP 8080.
- Qualsiasi pod con sia l'etichetta
Applica il manifest al cluster:
kubectl apply -f hello-world-service-2.yaml
Crea una risorsa Ingress
Crea una risorsa Ingress che specifichi le regole per il routing delle richieste in base al percorso dell'URL nella richiesta. Quando crei la risorsa Ingress, il controller GKE Ingress crea e configura un bilanciatore del carico delle applicazioni esterno.
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 una risorsa 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 una risorsa GKE Ingress utilizzandospec.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
ekubernetes.io/ingress.class
, GKE crea un bilanciatore del carico delle applicazioni esterno. Questo è lo stesso comportamento che si verifica se specifichi l'annotazionekubernetes.io/ingress.class: gce
. Per saperne di più, consulta Comportamento del controller Ingress di GKE.GKE crea un servizio di backend Google Cloud per ogni
backend.service
.Quando un client invia una richiesta al bilanciatore del carico con il percorso dell'URL
/
, GKE inoltra la richiesta al serviziohello-world-1
sulla porta 60000. Quando un client invia una richiesta al bilanciatore del carico utilizzando il percorso URL/v2
, GKE la inoltra al serviziohello-world-2
sulla porta 80. Per ulteriori informazioni sulle proprietàpath
epathType
, vedi Percorsi degli URL.
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 l'Application Load Balancer esterno:
Visualizza Ingress:
kubectl get ingress my-ingress --output yaml
L'output mostra l'indirizzo IP dell'Application Load Balancer esterno:
status: loadBalancer: ingress: - ip: 203.0.113.1
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.
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 la tua applicazione. Se vuoi accettare richieste HTTPS dai tuoi client, il bilanciatore del carico deve avere un certificato in modo da poter verificare la sua identità ai client. Il bilanciatore del carico deve anche avere una chiave privata per completare l'handshake HTTPS. Per ulteriori informazioni, vedi:
- Configurazione di HTTPS (TLS) tra client e bilanciatore del carico.
- Utilizzo di più certificati SSL nel bilanciamento del carico HTTPS con Ingress.
Percorsi degli URL
L'unico carattere jolly supportato per il campo path
di una risorsa Ingress è il carattere *
. Il carattere *
deve seguire una barra (/
) e
deve essere l'ultimo carattere del pattern. Ad esempio, /*
, /foo/*
e
/foo/bar/*
sono pattern validi, al contrario di *
, /foo/bar*
e /foo/*/bar
.
Un pattern più specifico ha la precedenza su un pattern meno specifico. Se
hai sia /foo/*
che /foo/bar/*
, allora /foo/bar/bat
viene considerato come corrispondenza
/foo/bar/*
. Per ulteriori informazioni sulle limitazioni dei percorsi e sulla corrispondenza dei pattern, consulta la documentazione di URL Maps.
Per i cluster GKE che eseguono versioni precedenti a 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
.
Disabilitazione di HTTP
Se vuoi che tutto il traffico tra il client e il bilanciatore del carico utilizzi HTTPS, puoi disattivare HTTP. Per maggiori informazioni, consulta la sezione Disabilitazione 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 maggiori 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 maggiori informazioni, 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 del container è predefinito e non richiede un'annotazione esplicita del servizio cloud.google.com/neg: '{"ingress": true}'
.
VPC condiviso
Se il cluster GKE in cui esegui 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, all'account di servizio GKE del progetto di servizio devono essere concesse le autorizzazioni IAM appropriate nel progetto host, come descritto nella sezione 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 che il traffico in entrata per i controlli di integrità di 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à di 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 in entrata
Annotazione | Description |
---|---|
kubernetes.io/ingress.allow-http | Specifica se consentire il traffico HTTP tra il client e il bilanciatore del carico HTTP(S). I valori possibili sono "true" e "false". Il valore predefinito è "true". Consulta la sezione Disattivazione del protocollo HTTP. |
ingress.gcp.kubernetes.io/pre-shared-cert | Utilizza questa annotazione per collegare le risorse del certificato alle risorse GKE Ingress. Per maggiori informazioni, consulta la pagina relativa all'utilizzo di più certificati SSL con bilanciatori del carico delle applicazioni esterni. |
kubernetes.io/ingress.global-static-ip-name | Utilizza questa annotazione per specificare che il bilanciatore del carico deve utilizzare un indirizzo IP esterno statico che hai creato in precedenza. Consulta la pagina relativa agli indirizzi IP statici per i bilanciatori del carico HTTP(S). |
networking.gke.io/v1beta1.FrontendConfig | Utilizza questa annotazione per personalizzare la configurazione lato client del bilanciatore del carico. Per maggiori informazioni, consulta la pagina relativa alla configurazione in entrata. |
networking.gke.io/suppress-firewall-xpn-error | Per i bilanciatori del carico Ingress, se Kubernetes non può modificare le regole firewall a causa
di autorizzazioni insufficienti, viene creato un evento firewallXPNError ogni
alcuni minuti. In GLBC 1.4 e versioni successive, puoi disattivare l'evento firewallXPNError aggiungendo l'annotazione networking.gke.io/suppress-firewall-xpn-error: "true" alla risorsa in entrata. Per riattivare l'audio puoi rimuovere questa annotazione. I valori possibili sono true e false .
Il valore predefinito è false .
|
Annotazioni di servizio relative a Ingress
Annotazione | Description |
---|---|
cloud.google.com/app-protocols | Utilizza questa annotazione per impostare il protocollo per la comunicazione tra il bilanciatore del carico e l'applicazione. I protocolli possibili sono HTTP, HTTPS e HTTP2. Consulta le pagine HTTPS tra il bilanciatore del carico e l'applicazione e HTTP/2 per il bilanciamento del carico con Ingress. |
cloud.google.com/backend-config | Utilizza questa annotazione per configurare il servizio di backend associato a un servizio. Per maggiori informazioni, consulta la pagina relativa alla configurazione in entrata. |
cloud.google.com/neg | Utilizza questa annotazione per specificare che il bilanciatore del carico deve utilizzare i gruppi di endpoint di rete. Consulta la pagina relativa all'utilizzo del bilanciamento del carico nativo del container. |
Passaggi successivi
- Leggi una panoramica concettuale di Ingress per Application Load Balancer esterni in GKE.
- Esegui il tutorial sulla 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.