Panoramica
Questa pagina fornisce una guida completa per la configurazione di Kubernetes Ingress suGoogle Cloud. Questa pagina descrive in dettaglio come utilizzare le risorse personalizzate FrontendConfig per gestire le funzionalità di frontend come le policy SSL e i reindirizzamenti HTTPS e le risorse personalizzate BackendConfig per ottimizzare le impostazioni di backend come i timeout dei servizi, Cloud CDN, le policy di sicurezza di Google Cloud Armor e Identity-Aware Proxy (IAP).
Per una panoramica concettuale di alto livello di queste funzionalità e dell'architettura sottostante di GKE Ingress, consulta:
Questa pagina è rivolta agli specialisti di networking che progettano e creano l'architettura della rete per la propria organizzazione e installano, configurano e supportano le apparecchiature di rete. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti diGoogle Cloud , consulta Ruoli e attività comuni degli utenti GKE.
Confronto delle funzioni
Le sezioni seguenti confrontano le proprietà dell'architettura e le funzionalità supportate per le classi Ingress su Google Cloud. Ove applicabile, le tabelle indicano la fase di lancio Disponibilità generale (GA) o Beta. Le funzionalità con una versione GKE elencata sono supportate a partire da quella versione. Le funzionalità senza una versione elencata sono supportate su tutte le versioni GKE disponibili.
Architettura e ambito
La tabella seguente mette a confronto le proprietà architettoniche delle classi Ingress:
| Proprietà | Ingress esterno | Ingress interno | Ingress multi-cluster |
|---|---|---|---|
| Controller Ingress | Controller Ingress ospitato da Google | Controller Ingress ospitato da Google | Controller Ingress ospitato da Google |
| Tipo di bilanciatore del caricoGoogle Cloud | Bilanciatore del carico HTTP(S) esterno | LB HTTP(S) interno | Bilanciatore del carico HTTP(S) esterno |
| Ambito cluster | Cluster singolo | Cluster singolo | Cluster multipli |
| Ambito del bilanciatore del carico | Globale | Regionale | Globale |
| Supporto dell'ambiente | GKE | GKE | GKE |
| Supporto di VPC condiviso | GA | GA | GA |
Annotazioni di servizio
La tabella seguente elenca le funzionalità di annotazione dei servizi supportate per classe Ingress:
| Funzionalità | Ingress esterno | Ingress interno | Ingress multi-cluster |
|---|---|---|---|
| Bilanciamento del carico nativo del container (NEG) | GA | GA | GA |
| HTTPS dal bilanciatore del carico ai backend | GA | GA | GA |
| HTTP/2 | GA |
GA |
GA |
Annotazioni Ingress
La tabella seguente elenca le funzionalità di annotazione Ingress supportate per classe Ingress:
| Funzionalità | Ingress esterno | Ingress interno | Ingress multi-cluster |
|---|---|---|---|
| Indirizzi IP statici | GA | GA | GA |
| Certificati basati su secret Kubernetes | GA | GA | GA |
| Certificati SSL autogestiti | GA | GA | GA |
| Certificati SSL gestiti da Google | GA | Non supportata | GA |
Funzionalità di FrontendConfig
La tabella seguente elenca le funzionalità FrontendConfig supportate per classe Ingress:
| Funzionalità | Ingress esterno | Ingress interno | Ingress multi-cluster |
|---|---|---|---|
| Policy SSL | GA | GA con gateway | GA |
| Reindirizzamento da HTTP a HTTPS |
1.17.13-gke.2600+ |
Non supportata | GA |
Funzionalità di BackendConfig
La tabella seguente elenca le funzionalità BackendConfig supportate per classe Ingress:
| Funzionalità | Ingress esterno | Ingress interno | Ingress multi-cluster |
|---|---|---|---|
| Timeout del servizio di backend | GA | GA | GA |
| Cloud CDN | GA | Non supportata | GA |
| Timeout per svuotamento della connessione | GA | GA | GA |
| Configurazione del controllo di integrità del bilanciatore del carico personalizzato | GA | GA | GA |
| Policy di sicurezza di Google Cloud Armor |
1.19.10-gke.700+ |
Non supportata | GA |
| Configurazione del logging degli accessi HTTP | GA | GA | GA |
| Identity-Aware Proxy (IAP) | GA | GA | GA |
| Affinità di sessione | GA | GA | GA |
| Intestazioni delle richieste definite dall'utente | GA | Non supportata | GA |
| Intestazioni delle risposte personalizzate |
1.25-gke+ |
Non supportata | Non supportata |
Configurazione di Ingress utilizzando il controller predefinito
Non puoi configurare manualmente le funzionalità di LoadBalancer utilizzando Google Cloud SDK o la console Google Cloud . Devi utilizzare le risorse Kubernetes BackendConfig o FrontendConfig.
Quando crei un Ingress utilizzando il controller predefinito, puoi scegliere il tipo di bilanciatore del carico (un bilanciatore del carico delle applicazioni esterno o un bilanciatore del carico delle applicazioni interno) utilizzando un'annotazione sull'oggetto Ingress. Puoi scegliere se GKE crea NEG di zona o se utilizza gruppi di istanze utilizzando un'annotazione su ogni oggetto Service.
Le definizioni di risorse personalizzate (CRD) FrontendConfig e BackendConfig consentono di personalizzare ulteriormente il bilanciatore del carico. Queste CRD consentono di definire ulteriori funzionalità del bilanciatore del carico in modo gerarchico, più strutturato rispetto alle annotazioni. Per utilizzare Ingress (e queste CRD), devi attivare il componente aggiuntivo per il bilanciamento del carico HTTP. I cluster GKE hanno il bilanciamento del carico HTTP abilitato per impostazione predefinita, che non deve essere disabilitato.
Gli oggetti FrontendConfig sono referenziati in un oggetto Ingress e possono essere utilizzati solo con Ingress esterni. Gli oggetti BackendConfig sono referenziati da un oggetto Service. Gli stessi CRD possono essere referenziati da più oggetti Service o Ingress per garantire la coerenza della configurazione. I CRD FrontendConfig e BackendConfig condividono lo stesso ciclo di vita delle risorse Ingress e Service corrispondenti e spesso vengono distribuiti insieme.
Il seguente diagramma illustra come:
Un'annotazione su un oggetto Ingress o MultiClusterIngress fa riferimento a un CRD FrontendConfig. La CRD FrontendConfig fa riferimento a una policy SSL Google Cloud.
Un'annotazione su un oggetto Service o MultiClusterService fa riferimento a un CRD BackendConfig. La CRD BackendConfig specifica le impostazioni personalizzate per il controllo di integrità del servizio di backend corrispondente.
Associazione di FrontendConfig all'oggetto Ingress
FrontendConfig può essere utilizzato solo con Ingress esterni.
Puoi associare un FrontendConfig a un Ingress o a un MultiClusterIngress.
In entrata
Utilizza l'annotazione networking.gke.io/v1beta1.FrontendConfig:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
annotations:
networking.gke.io/v1beta1.FrontendConfig: "FRONTENDCONFIG_NAME"
...
Sostituisci FRONTENDCONFIG_NAME con il nome della tua risorsa FrontendConfig.
MultiClusterIngress
Utilizza l'annotazione networking.gke.io/frontend-config:
apiVersion: networking.gke.io/v1
kind: MultiClusterIngress
metadata:
annotations:
networking.gke.io/frontend-config: "FRONTENDCONFIG_NAME"
...
Sostituisci FRONTENDCONFIG_NAME con il nome della tua risorsa FrontendConfig.
Associazione di BackendConfig a Ingress
Puoi utilizzare l'annotazione cloud.google.com/backend-config o beta.cloud.google.com/backend-config per specificare il nome di un BackendConfig.
Stessa configurazione BackendConfig per tutte le porte del servizio
Per utilizzare lo stesso BackendConfig per tutte le porte, utilizza la chiave default nell'annotazione. Il controller Ingress utilizza lo stesso BackendConfig ogni volta che crea un servizio di backend del bilanciatore del carico per fare riferimento a una delle porte del servizio.
Puoi utilizzare la chiave default per le risorse Ingress e MultiClusterIngress.
apiVersion: v1
kind: Service
metadata:
annotations:
cloud.google.com/backend-config: '{"default": "my-backendconfig"}'
...
BackendConfig univoco per porta di servizio
Sia per Ingress che per MultiClusterIngress, puoi specificare un BackendConfig personalizzato per una o più porte utilizzando una chiave che corrisponde al nome o al numero della porta. Il controller Ingress utilizza la risorsa BackendConfig specifica quando crea un servizio di backend del bilanciatore del carico per una porta del servizio di riferimento.
GKE 1.16-gke.3 e versioni successive
apiVersion: v1
kind: Service
metadata:
annotations:
cloud.google.com/backend-config: '{"ports": {
"SERVICE_REFERENCE_A":"BACKENDCONFIG_REFERENCE_A",
"SERVICE_REFERENCE_B":"BACKENDCONFIG_REFERENCE_B"
}}'
spec:
ports:
- name: PORT_NAME_1
port: PORT_NUMBER_1
protocol: TCP
targetPort: 50000
- name: PORT_NAME_2
port: PORT_NUMBER_2
protocol: TCP
targetPort: 8080
...
Tutte le versioni supportate
apiVersion: v1
kind: Service
metadata:
annotations:
cloud.google.com/backend-config: '{"ports": {
"PORT_NAME_1":"BACKENDCONFIG_REFERENCE_A",
"PORT_NAME_2":"BACKENDCONFIG_REFERENCE_B"
}}'
spec:
ports:
- name: PORT_NAME_1
port: PORT_NUMBER_1
protocol: TCP
targetPort: 50000
- name: PORT_NAME_2
port: PORT_NUMBER_2
protocol: TCP
targetPort: 8080
...
Sostituisci quanto segue:
BACKENDCONFIG_REFERENCE_A: il nome di un BackendConfig esistente.BACKENDCONFIG_REFERENCE_B: il nome di un BackendConfig esistente.SERVICE_REFERENCE_A: utilizza il valore diPORT_NUMBER_1oPORT_NAME_1. Questo perché l'annotazione BackendConfig di un servizio può fare riferimento al nome della porta (spec.ports[].name) o al numero della porta (spec.ports[].port).SERVICE_REFERENCE_B: utilizza il valore diPORT_NUMBER_2oPORT_NAME_2. Questo perché l'annotazione BackendConfig di un servizio può fare riferimento al nome della porta (spec.ports[].name) o al numero della porta (spec.ports[].port).
Quando fai riferimento alla porta del servizio in base al numero, devi utilizzare il valore port anziché il valore targetPort. Il numero di porta utilizzato qui serve solo per l'associazione di BackendConfig; non controlla la porta a cui il bilanciatore del carico invia il traffico o i probe di controllo di integrità:
Quando utilizzi il bilanciamento del carico nativo del container, il bilanciatore del carico invia il traffico a un endpoint in un gruppo di endpoint di rete (corrispondente a un indirizzo IP del pod) sulla
targetPortdella porta del servizio di riferimento (che deve corrispondere a uncontainerPortper un pod di distribuzione). In caso contrario, il bilanciatore del carico invia il traffico all'indirizzo IP di un nodo sulla portanodePortdel servizio di riferimento.Quando utilizzi un BackendConfig per fornire un controllo di integrità del bilanciatore del carico personalizzato, il numero di porta che utilizzi per il controllo di integrità del bilanciatore del carico può essere diverso dal numero
spec.ports[].portdel servizio. Per informazioni dettagliate sui numeri di porta per i controlli di integrità, consulta Configurazione controllo di integrità personalizzati.
Configurazione delle funzionalità di Ingress tramite i parametri FrontendConfig
La sezione seguente mostra come impostare FrontendConfig per attivare funzionalità Ingress specifiche.
Criteri SSL
Le policy SSL consentono di specificare un insieme di versioni e crittografie TLS utilizzate dal bilanciatore del carico per terminare il traffico HTTPS proveniente dai client. Devi prima creare una policy SSL al di fuori di GKE. Una volta creato, puoi farvi riferimento in una CRD FrontendConfig.
Il campo sslPolicy in FrontendConfig fa riferimento al nome di una policy SSL nello stesso progetto Google Cloud del cluster GKE. Collega la policy SSL al proxy HTTPS di destinazione, creato per il bilanciatore del carico HTTP(S) esterno da Ingress. La stessa risorsa FrontendConfig e la stessa policy SSL possono essere referenziate da più risorse Ingress. Se una policy SSL di riferimento viene modificata, la modifica viene propagata ai Google Front End (GFE) che alimentano il bilanciatore del carico HTTP(S) esterno creato da Ingress.
Il seguente manifest FrontendConfig abilita una policy SSL denominata gke-ingress-ssl-policy:
apiVersion: networking.gke.io/v1beta1
kind: FrontendConfig
metadata:
name: my-frontend-config
spec:
sslPolicy: gke-ingress-ssl-policy
Reindirizzamenti da HTTP a HTTPS
Un bilanciatore del carico HTTP esterno può reindirizzare le richieste HTTP non criptate a un bilanciatore del carico HTTPS che utilizza lo stesso indirizzo IP. Quando crei un Ingress con i reindirizzamenti da HTTP a HTTPS abilitati, entrambi i bilanciatori del carico vengono creati automaticamente. Le richieste all'indirizzo IP esterno dell'Ingress sulla porta 80 vengono reindirizzate automaticamente allo stesso indirizzo IP esterno sulla porta 443. Questa funzionalità si basa sui reindirizzamenti da HTTP a HTTPS forniti da Cloud Load Balancing.
Per supportare il reindirizzamento da HTTP a HTTPS, un Ingress deve essere configurato per gestire sia il traffico HTTP che quello HTTPS. Se HTTP o HTTPS sono disattivati, il reindirizzamento non funzionerà.
I reindirizzamenti da HTTP a HTTPS vengono configurati utilizzando il campo redirectToHttps in una risorsa personalizzata FrontendConfig. I reindirizzamenti sono abilitati per l'intera risorsa Ingress, quindi tutti i servizi a cui fa riferimento Ingress avranno i reindirizzamenti HTTPS abilitati.
Il seguente manifest FrontendConfig attiva i reindirizzamenti da HTTP a HTTPS. Imposta il campo spec.redirectToHttps.enabled su true per attivare i reindirizzamenti HTTPS. Il campo spec.responseCodeName è facoltativo. Se viene omesso, viene utilizzato un reindirizzamento 301 Moved
Permanently.
apiVersion: networking.gke.io/v1beta1
kind: FrontendConfig
metadata:
name: my-frontend-config
spec:
redirectToHttps:
enabled: true
responseCodeName: RESPONSE_CODE
Sostituisci RESPONSE_CODE con una delle seguenti opzioni:
MOVED_PERMANENTLY_DEFAULTper restituire un codice di risposta di reindirizzamento 301 (predefinito seresponseCodeNamenon è specificato).FOUNDper restituire un codice di risposta di reindirizzamento 302.SEE_OTHERper restituire un codice di risposta di reindirizzamento 303.TEMPORARY_REDIRECTper restituire un codice di risposta di reindirizzamento 307.PERMANENT_REDIRECTper restituire un codice di risposta di reindirizzamento 308.
Quando i reindirizzamenti sono abilitati, il controller Ingress crea un bilanciatore del carico come mostrato nel seguente diagramma:
Per verificare che il reindirizzamento funzioni, utilizza un comando curl:
curl http://IP_ADDRESS
Sostituisci IP_ADDRESS con l'indirizzo IP di Ingress.
La risposta mostra il codice di risposta reindirizzamento che hai configurato. Ad esempio,
il seguente esempio riguarda un FrontendConfig configurato con un
reindirizzamento 301: MovedPermanently:
<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
<TITLE>301 Moved</TITLE></HEAD><BODY>
<H1>301 Moved</H1>
The document has moved
<A HREF="https://35.244.160.59/">here</A>.</BODY></HTML>
Configurazione delle funzionalità di Ingress tramite i parametri BackendConfig
Le sezioni seguenti mostrano come impostare BackendConfig per abilitare funzionalità Ingress specifiche. Le modifiche a una risorsa BackendConfig vengono riconciliate costantemente, quindi non è necessario eliminare e ricreare l'oggetto Ingress per vedere che le modifiche di BackendConfig vengono applicate.
Per informazioni sulle limitazioni di BackendConfig, consulta la sezione Limitazioni.
Timeout del servizio di backend
Puoi utilizzare un BackendConfig per impostare un periodo di timeout del servizio di backend in secondi. Se non specifichi un valore, il valore predefinito è 30 secondi.
Il seguente manifest BackendConfig specifica un timeout di 40 secondi:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
timeoutSec: 40
Cloud CDN
Puoi abilitare Cloud CDN utilizzando un oggetto BackendConfig.
Il seguente manifest BackendConfig mostra tutti i campi disponibili quando abiliti Cloud CDN:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
cdn:
enabled: CDN_ENABLED
cachePolicy:
includeHost: INCLUDE_HOST
includeProtocol: INCLUDE_PROTOCOL
includeQueryString: INCLUDE_QUERY_STRING
# Specify only one of queryStringBlacklist and queryStringWhitelist.
queryStringBlacklist: QUERY_STRING_DENYLIST
queryStringWhitelist: QUERY_STRING_ALLOWLIST
cacheMode: CACHE_MODE
clientTtl: CLIENT_TTL
defaultTtl: DEFAULT_TTL
maxTtl: MAX_TTL
negativeCaching: NEGATIVE_CACHING
negativeCachingPolicy:
code: NEGATIVE_CACHING_CODE
ttl: NEGATIVE_CACHING_TTL
requestCoalescing: REQ_COALESCING
# Time, in seconds, to continue serving a stale version after request expiry.
serveWhileStale: SERVE_WHILE_STALE
signedUrlCacheMaxAgeSec: SIGNED_MAX_AGE
signedUrlKeys:
keyName: KEY_NAME
keyValue: KEY_VALUE
secretName: SECRET_NAME
Sostituisci quanto segue:
CDN_ENABLED: se impostato sutrue, Cloud CDN è abilitato per questo backend Ingress.INCLUDE_HOST: se impostato sutrue, le richieste a host diversi vengono memorizzate nella cache separatamente.INCLUDE_PROTOCOL: se impostato sutrue, le richieste HTTP e HTTPS vengono memorizzate nella cache separatamente.INCLUDE_QUERY_STRING: se impostato sutrue, i parametri della stringa di query vengono inclusi nella chiave cache in base aqueryStringBlacklistoqueryStringWhitelist. Se non viene impostato nessuno dei due, viene inclusa l'intera stringa di query. Se impostato sufalse, l'intera stringa di query viene esclusa dalla chiave cache.QUERY_STRING_DENYLIST: specifica un array di stringhe con i nomi dei parametri della stringa di query da escludere dalle chiavi cache. Tutti gli altri parametri sono inclusi. Puoi specificarequeryStringBlacklistoqueryStringWhitelist, ma non entrambi.QUERY_STRING_ALLOWLIST: specifica un array di stringhe con i nomi dei parametri della stringa di query da includere nelle chiavi cache. Tutti gli altri parametri vengono esclusi. Puoi specificarequeryStringBlacklistoqueryStringWhitelist, ma non entrambi.
I seguenti campi sono supportati solo nelle versioni GKE 1.23.3-gke.900 e successive utilizzando GKE Ingress. Non sono supportati utilizzando Ingress multi-cluster:
CACHE_MODE: la modalità cache.CLIENT_TTL,DEFAULT_TTLeMAX_TTL: configurazione TTL. Per saperne di più, consulta Utilizzo delle impostazioni e degli override TTL.NEGATIVE_CACHING: se impostato sutrue, la memorizzazione nella cache negativa è abilitata. Per saperne di più, consulta Utilizzo della memorizzazione nella cache negativa.NEGATIVE_CACHING_CODEeNEGATIVE_CACHING_TTL: configurazione della memorizzazione nella cache negativa. Per saperne di più, consulta Utilizzo della memorizzazione nella cache negativa.REQ_COALESCING: se impostato sutrue, la compressione è abilitata. Per saperne di più, consulta Compressione (coalescenza) delle richieste.SERVE_WHILE_STALE: il tempo, in secondi, dopo la scadenza della risposta durante il quale Cloud CDN continua a pubblicare una versione scaduta. Per saperne di più, consulta Pubblicazione di contenuti scaduti.SIGNED_MAX_AGE: il tempo massimo in secondi per cui le risposte possono essere memorizzate nella cache. Per saperne di più, consulta Personalizzazione facoltativa del tempo di memorizzazione nella cache massimo.KEY_NAME,KEY_VALUEeSECRET_NAME: configurazione della chiave URL firmata. Per saperne di più, consulta Creazione di chiavi della richiesta firmata.
Espandi la sezione seguente per visualizzare un esempio di deployment di Cloud CDN tramite Ingress e verifica che i contenuti dell'applicazione vengano memorizzati nella cache.
Timeout per svuotamento della connessione
Puoi configurare il timeout di svuotamento della connessione utilizzando un BackendConfig. Il timeout per lo svuotamento della connessione è il tempo, in secondi, di attesa per lo svuotamento delle connessioni. Per la durata specificata del timeout, alle richieste esistenti al backend rimosso viene concesso il tempo necessario per il completamento. Il bilanciatore del carico non invia nuove richieste al backend rimosso. Una volta raggiunta la durata del timeout, tutte le connessioni rimanenti al backend vengono chiuse. La durata del timeout può essere compresa tra 0 e 3600 secondi. Il valore predefinito è 0, che disattiva anche lo svuotamento della connessione.
Il seguente manifest BackendConfig specifica un timeout di svuotamento della connessione di 60 secondi:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
connectionDraining:
drainingTimeoutSec: 60
Configurazione del controllo di integrità personalizzato
Esistono diversi modi in cui GKE configura i controlli di integrità dei bilanciatori del caricoGoogle Cloud durante il deployment tramite Ingress. Per scoprire di più su come GKE Ingress esegue il deployment dei controlli di integrità, consulta Controlli di integrità di Ingress.
Un BackendConfig ti consente di controllare con precisione le impostazioni del controllo di integrità del bilanciatore del carico.
Puoi configurare più servizi GKE in modo che facciano riferimento allo stesso BackendConfig come modello riutilizzabile. Per i parametri healthCheck, viene creato un controllo di integritàGoogle Cloud univoco per ogni servizio di backend corrispondente a ogni servizio GKE.
Il seguente manifest BackendConfig mostra tutti i campi disponibili durante la configurazione di un controllo di integrità BackendConfig:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
healthCheck:
# Time, in seconds, between prober checks. Default is `5`.
checkIntervalSec: INTERVAL
# Probe timeout period. Must be less than or equal to checkIntervalSec.
timeoutSec: TIMEOUT
healthyThreshold: HEALTH_THRESHOLD
unhealthyThreshold: UNHEALTHY_THRESHOLD
# Protocol to use. Must be `HTTP`, `HTTP2`, or `HTTPS`.
type: PROTOCOL
# Path for probe to use. Default is `/`.
requestPath: PATH
# Port number of the load balancer health check port. Default is `80`.
port: PORT
Sostituisci quanto segue:
INTERVAL: specifica l'intervallocheck-interval, in secondi, per ogni agente di controllo di integrità. Questo è il tempo che intercorre tra l'inizio di un controllo di un prober e l'inizio del controllo successivo. Se ometti questo parametro, viene utilizzato il valore predefinito di 5 secondi di Google Cloud . Per ulteriori dettagli sull'implementazione, consulta Sonde multiple e frequenza.TIMEOUT: specifica il tempo di attesa da parte di Google Cloud per una risposta a un probe. Il valore diTIMEOUTdeve essere inferiore o uguale aINTERVAL. Il valore è espresso in secondi. Ogni probe richiede la restituzione di un codice di rispostaHTTP 200 (OK)prima del timeout del probe.HEALTH_THRESHOLDeUNHEALTHY_THRESHOLD: specifica il numero di tentativi di connessione sequenziali che devono riuscire o non riuscire, per almeno un prober, per modificare lo stato di integrità da integro a non integro o viceversa. Se ometti uno di questi parametri,Google Cloud utilizza il valore predefinito 2.PROTOCOL: specifica un protocollo utilizzato dai sistemi di probe per il controllo di integrità.BackendConfigsupporta solo la creazione di controlli di integrità che utilizzano i protocolli HTTP, HTTPS o HTTP2. Per saperne di più, consulta Criteri di esito positivo per HTTP, HTTPS e HTTP/2. Non puoi omettere questo parametro.PATH: per i controlli di integrità HTTP, HTTPS o HTTP2, specifica ilrequest-patha cui deve connettersi il sistema di probe. Se ometti questo parametro,Google Cloud utilizza il valore predefinito/.PORT: un BackendConfig supporta solo la specifica della porta del controllo di integrità del bilanciatore del carico utilizzando un numero di porta. Se ometti questo parametro, Google Cloud utilizza il valore predefinito80.Quando utilizzi il bilanciamento del carico nativo del container, devi selezionare una porta corrispondente a un
containerPortdi un pod di distribuzione (indipendentemente dal fatto che ilcontainerPortsia o meno referenziato da untargetPortdel servizio). Poiché il bilanciatore del carico invia i probe direttamente all'indirizzo IP del pod, non hai un limite dicontainerPorta cui fa riferimento iltargetPortdi un servizio. I sistemi di probe del controllo di integrità si connettono all'indirizzo IP di un pod di distribuzione sulla porta specificata.Per i backend dei gruppi di istanze, devi selezionare una porta corrispondente a un
nodePortesposto dal servizio. I sistemi di probe del controllo di integrità si connettono quindi a ciascun nodo su quella porta.
Per configurare GKE Ingress con un controllo di integrità HTTP personalizzato, consulta GKE Ingress con controllo di integrità HTTP personalizzato.
Policy di sicurezza Ingress di Google Cloud Armor
Le policy di sicurezza di Google Cloud Armor ti aiutano a proteggere le tue applicazioni con bilanciamento del carico dagli attacchi basati sul web. Dopo aver configurato una policy di sicurezza di Google Cloud Armor, puoi farvi riferimento utilizzando un oggetto BackendConfig.
Aggiungi il nome della policy di sicurezza a BackendConfig. Il seguente manifest BackendConfig specifica una policy di sicurezza denominata example-security-policy:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
namespace: cloud-armor-how-to
name: my-backendconfig
spec:
securityPolicy:
name: "example-security-policy"
Due fonti di riferimento
Anche se configurate tramite GKE, le API Compute Engine BackendService sottostanti possono comunque essere utilizzate per modificare direttamente la policy di sicurezza da applicare. In questo modo vengono create due fonti di attendibilità: GKE e Compute Engine. Per evitare conflitti e comportamenti imprevisti, ti consigliamo di utilizzare GKE BackendConfig per la gestione della policy di sicurezza da utilizzare. La tabella seguente descrive il comportamento del controller Ingress di GKE in risposta al campo securityPolicy all'interno di BackendConfig:
| Campo BackendConfig | Valore | Comportamento |
|---|---|---|
spec.securityPolicy.name |
CloudArmorPolicyName |
Il controller GKE Ingress imposta la policy Cloud Armor denominata CloudArmorPolicyName sul bilanciatore del carico. Il controller GKE Ingress sovrascrive qualsiasi policy impostata in precedenza. |
spec.securityPolicy.name |
Stringa vuota ("") |
Il controller GKE Ingress rimuove dal bilanciatore del carico qualsiasi policy di Cloud Armor configurata. |
spec.securityPolicy |
null |
Il controller Ingress di GKE utilizza la configurazione impostata sull'oggetto BackendService configurato tramite l'API Compute Engine utilizzando la console Google Cloud , gcloud CLI o Terraform. |
Per configurare GKE Ingress con la protezione di Google Cloud Armor, consulta Ingress abilitato per Google Cloud Armor.
Logging degli accessi HTTP
types (including Multi Cluster Ingress). Opening parenthesis:Ingress può registrare tutte le richieste HTTP dai client in Cloud Logging. Puoi abilitare e disabilitare il logging degli accessi utilizzando BackendConfig, oltre a impostare la frequenza di campionamento del logging degli accessi.
Per configurare il logging degli accessi, utilizza il campo logging in BackendConfig. Se logging viene omesso, il logging degli accessi assume il comportamento predefinito. Questo dipende dalla versione di GKE.
Puoi configurare i seguenti campi:
enable: se impostato sutrue, il logging degli accessi verrà abilitato per questo Ingress e i log saranno disponibili in Cloud Logging. In caso contrario, il logging degli accessi è disattivato per questo Ingress.sampleRate: specifica un valore compreso tra 0.0 e 1.0, dove 0.0 indica che non viene registrato nessun pacchetto e 1.0 indica che viene registrato il 100% dei pacchetti. Questo campo è pertinente solo seenableè impostato sutrue.sampleRateè un campo facoltativo, ma se è configurato, deve essere impostato ancheenable: true, altrimenti viene interpretato comeenable: false.
Il seguente manifest BackendConfig abilita il logging degli accessi e imposta la frequenza di campionamento sul 50% delle richieste HTTP per una determinata risorsa Ingress:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
logging:
enable: true
sampleRate: 0.5
Identity-Aware Proxy
Per configurare BackendConfig per Identity-Aware Proxy IAP, devi specificare i valori enabled e secretName nel blocco iap in BackendConfig. Per specificare questi valori, assicurati che l'agente di servizio GKE disponga dell'autorizzazione compute.backendServices.update.
Il seguente manifest BackendConfig abilita Identity-Aware Proxy:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
iap:
enabled: true
oauthclientCredentials:
secretName: my-secret
Abilita IAP con il client OAuth gestito da Google
A partire da GKE 1.29.4-gke.1043000, IAP può essere configurato per utilizzare il client OAuth gestito da Google utilizzando un BackendConfig. Per decidere se utilizzare il client OAuth gestito da Google o un client OAuth personalizzato, consulta Quando utilizzare una configurazione OAuth personalizzata nella documentazione di IAP.
Per abilitare IAP con il client OAuth gestito da Google, non fornire oauthclientCredentials in BackendConfig. Per gli utenti che hanno già configurato IAP utilizzando oauthclientCredentials, non esiste un percorso di migrazione per passare all'utilizzo del client OAuth gestito da Google: devi ricreare il backend (rimuovere il servizio dall'Ingress e ricollegarlo). Ti consigliamo di eseguire questa operazione durante un periodo di manutenzione, poiché causerà tempi di inattività. È possibile eseguire il percorso di migrazione opposto, ovvero passare dal client OAuth gestito da Google a oauthclientCredentials.
Il seguente manifest BackendConfig abilita Identity-Aware Proxy con il client OAuth gestito da Google:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
iap:
enabled: true
Per istruzioni complete, consulta Abilitazione di IAP per GKE nella documentazione di IAP.
Identity-Aware Proxy con traffico in entrata interno
Per configurare Ingress interno per IAP, devi utilizzare il livello Premium. Se non utilizzi il livello Premium, non puoi visualizzare o creare bilanciatori del carico delle applicazioni interni con Identity-Aware Proxy. Per utilizzare Ingress interno per IAP, devi anche avere un abbonamento a Chrome Enterprise Premium.
Per configurare GKE Ingress sicuro con l'autenticazione basata su Identity-Aware Proxy, consulta l'esempio Ingress abilitato per IAP.
Affinità di sessione
Puoi utilizzare un BackendConfig per impostare l'affinità di sessione sull'IP client o sul cookie generato.
Affinità IP client
Per utilizzare un BackendConfig per impostare l'affinità IP client, imposta affinityType su "CLIENT_IP", come nell'esempio seguente:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
sessionAffinity:
affinityType: "CLIENT_IP"
Affinità cookie generato
Per utilizzare un BackendConfig per impostare l'affinità cookie generato, imposta affinityType su GENERATED_COOKIE nel manifest BackendConfig. Puoi anche utilizzare
affinityCookieTtlSec per impostare il periodo di tempo in cui il cookie rimane attivo.
Il seguente manifest imposta il tipo di affinità sul cookie generato e assegna ai cookie un TTL di 50 secondi:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
sessionAffinity:
affinityType: "GENERATED_COOKIE"
affinityCookieTtlSec: 50
Intestazioni delle richieste definite dall'utente
Puoi utilizzare un BackendConfig per configurare le intestazioni delle richieste definite dall'utente. Il bilanciatore del carico aggiunge le intestazioni specificate alle richieste che inoltra ai backend.
Il bilanciatore del carico aggiunge intestazioni della richiesta personalizzate solo alle richieste del client, non ai probe del controllo di integrità. Se il backend richiede un'intestazione specifica per l'autorizzazione che non è presente nel pacchetto del controllo di integrità, il controllo di integrità potrebbe non riuscire.
Per attivare le intestazioni delle richieste definite dall'utente, specifica un elenco di intestazioni nella proprietà customRequestHeaders della risorsa BackendConfig. Specifica ogni intestazione come stringa header-name:header-value.
Il seguente manifest BackendConfig aggiunge tre intestazioni della richiesta:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
customRequestHeaders:
headers:
- "X-Client-Region:{client_region}"
- "X-Client-City:{client_city}"
- "X-Client-CityLatLong:{client_city_lat_long}"
Intestazioni delle risposte personalizzate
Per abilitare le intestazioni delle risposte personalizzate, specifica un elenco di intestazioni nella proprietà customResponseHeaders della risorsa BackendConfig. Specifica ogni intestazione come stringa header-name:header-value.
Le intestazioni della risposta personalizzate sono disponibili solo nei cluster GKE versione 1.25 e successive.
Il seguente manifest BackendConfig è un esempio di aggiunta di un'intestazione della risposta HTTP Strict Transport Security (HSTS) per un Ingress esterno:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
customResponseHeaders:
headers:
- "Strict-Transport-Security: max-age=28800; includeSubDomains"
Esercizio: impostazione dei timeout di Ingress utilizzando un servizio di backend
L'esercizio seguente mostra i passaggi necessari per configurare i timeout e lo svuotamento della connessione con un Ingress con una risorsa BackendConfig.
Per configurare le proprietà del backend di un Ingress, completa le seguenti attività:
- Crea un deployment.
- Crea un BackendConfig.
- Crea un servizio e associa una delle sue porte a BackendConfig.
- Crea un Ingress e associalo alla coppia (servizio, porta).
- Convalida le proprietà del servizio di backend.
- Pulizia.
Creazione di un deployment
Prima di creare un BackendConfig e un Service, devi creare un Deployment.
Il seguente manifest di esempio è per un deployment denominato my-deployment.yaml:
# my-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-deployment
spec:
selector:
matchLabels:
purpose: bsc-config-demo
replicas: 2
template:
metadata:
labels:
purpose: bsc-config-demo
spec:
containers:
- name: hello-app-container
image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
Crea il deployment eseguendo questo comando:
kubectl apply -f my-deployment.yaml
Creazione di un oggetto BackendConfig
Utilizza BackendConfig per specificare le funzionalità di Ingress che vuoi utilizzare.
Questo manifest BackendConfig, denominato my-backendconfig.yaml, specifica:
- Un timeout di 40 secondi.
- Un timeout per lo svuotamento della connessione di 60 secondi.
# my-backendconfig.yaml
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
timeoutSec: 40
connectionDraining:
drainingTimeoutSec: 60
Crea il BackendConfig eseguendo questo comando:
kubectl apply -f my-backendconfig.yaml
Crea un Service
Un BackendConfig corrisponde a una singola combinazione di porta di servizio, anche se un servizio ha più porte. Ogni porta può essere associata a un singolo CRD BackendConfig. Se una porta di servizio è indicata da un Ingress e se la porta di servizio è associata a un BackendConfig, il servizio di backend di bilanciamento del carico HTTP(S) prende parte della sua configurazione dal BackendConfig.
Di seguito è riportato un esempio di manifest del servizio denominato my-service.yaml:
# my-service.yaml
apiVersion: v1
kind: Service
metadata:
name: my-service
# Associate the Service with Pods that have the same label.
labels:
purpose: bsc-config-demo
annotations:
# Associate TCP port 80 with a BackendConfig.
cloud.google.com/backend-config: '{"ports": {"80":"my-backendconfig"}}'
cloud.google.com/neg: '{"ingress": true}'
spec:
type: ClusterIP
selector:
purpose: bsc-config-demo
ports:
# Forward requests from port 80 in the Service to port 8080 in a member Pod.
- port: 80
protocol: TCP
targetPort: 8080
L'annotazione cloud.google.com/backend-config specifica una mappatura tra le porte e gli oggetti BackendConfig. In my-service.yaml:
- Qualsiasi pod con l'etichetta
purpose: bsc-config-demoè membro del servizio. - La porta TCP 80 del servizio è associata a un BackendConfig denominato
my-backendconfig. L'annotazionecloud.google.com/backend-configlo specifica. - Una richiesta inviata alla porta 80 del servizio viene inoltrata a uno dei pod membri sulla porta 8080.
Per creare il servizio, esegui questo comando:
kubectl apply -f my-service.yaml
Creare una risorsa Ingress
Di seguito è riportato un manifest Ingress denominato my-ingress.yaml.. In questo esempio, le richieste in entrata vengono indirizzate alla porta 80 del servizio denominato my-service.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-ingress
spec:
rules:
# Route all HTTP requests to port 80 in a Service.
- http:
paths:
- path: /*
pathType: ImplementationSpecific
backend:
service:
name: my-service
port:
number: 80
Per creare l'oggetto Ingress, esegui questo comando:
kubectl apply -f my-ingress.yaml
Attendi qualche minuto affinché il controller Ingress configuri un bilanciatore del carico delle applicazioni esterno e un servizio di backend associato. Al termine, avrai configurato Ingress in modo che utilizzi un timeout di 40 secondi e un timeout di svuotamento della connessione di 60 secondi.
Convalida delle proprietà del servizio di backend
Puoi verificare che le impostazioni del bilanciatore del carico siano state applicate correttamente tramite BackendConfig. Per farlo, identifica il servizio di backend di cui Ingress ha eseguito il deployment e controlla le sue impostazioni per verificare che corrispondano ai manifest di deployment.
Innanzitutto, descrivi la risorsa my-ingress e filtra l'annotazione che elenca i servizi di backend associati all'oggetto Ingress. Ad esempio:
kubectl describe ingress my-ingress | grep ingress.kubernetes.io/backends
Dovresti vedere un output simile al seguente:
ingress.kubernetes.io/backends: '{"k8s1-27fde173-default-my-service-80-8d4ca500":"HEALTHY","k8s1-27fde173-kube-system-default-http-backend-80-18dfe76c":"HEALTHY"}'
L'output fornisce informazioni sui servizi di backend. Ad esempio, questa annotazione contiene due servizi di backend:
"k8s1-27fde173-default-my-service-80-8d4ca500":"HEALTHY"fornisce informazioni sul servizio di backend associato al servizio Kubernetesmy-service.k8s1-27fde173è un hash utilizzato per descrivere il cluster.defaultè lo spazio dei nomi Kubernetes.HEALTHYindica che il backend è integro.
"k8s1-27fde173-kube-system-default-http-backend-80-18dfe76c":"HEALTHY"fornisce informazioni sul servizio di backend associato al backend predefinito (server 404).k8s1-27fde173è un hash utilizzato per descrivere il cluster.kube-systemè lo spazio dei nomi.default-http-backendè il nome del servizio Kubernetes.80è la porta dell'host.HEALTHYindica che il backend è integro.
Successivamente, ispeziona il servizio di backend associato a my-service utilizzando gcloud.
Filtra per "drainingTimeoutSec" e "timeoutSec" per verificare che siano stati impostati nel control plane del bilanciatore del carico Google Cloud . Ad esempio:
# Optionally, set a variable
export BES=k8s1-27fde173-default-my-service-80-8d4ca500
# Filter for drainingTimeoutSec and timeoutSec
gcloud compute backend-services describe ${BES} --global | grep -e "drainingTimeoutSec" -e "timeoutSec"
Output:
drainingTimeoutSec: 60
timeoutSec: 40
La presenza di drainingTimeoutSec e timeoutSec nell'output conferma che i relativi valori sono stati impostati correttamente tramite BackendConfig.
Pulizia
Per evitare addebiti indesiderati sul tuo account, elimina gli oggetti Kubernetes che hai creato per questo esercizio:
kubectl delete ingress my-ingress
kubectl delete service my-service
kubectl delete backendconfig my-backendconfig
kubectl delete deployment my-deployment
Limitazioni di BackendConfig
I BackendConfig presentano le seguenti limitazioni:
Una sola coppia (servizio, porta) può utilizzare un solo BackendConfig, anche se più oggetti Ingress fanno riferimento alla coppia (servizio, porta). Ciò significa che tutti gli oggetti Ingress che fanno riferimento alla stessa coppia (servizio, porta) devono utilizzare la stessa configurazione per Cloud Armor, IAP e Cloud CDN.
IAP e Cloud CDN non possono essere abilitati per lo stesso servizio di backend di bilanciamento del carico HTTP(S). Ciò significa che non puoi configurare sia IAP che Cloud CDN nello stesso BackendConfig.
Per interagire con BackendConfig, devi utilizzare
kubectl1.7 o versioni successive.
Rimozione della configurazione specificata in un FrontendConfig o BackendConfig
Per revocare una funzionalità Ingress, devi disabilitare esplicitamente la configurazione della funzionalità nella CRD FrontendConfig o BackendConfig. Il controller Ingress riconcilia solo le configurazioni specificate in questi CRD.
Per cancellare o disattivare una configurazione attivata in precedenza, imposta il valore del campo su una stringa vuota ("") o su un valore booleano false, a seconda del tipo di campo.
Il seguente manifest BackendConfig disabilita una policy di sicurezza di Google Cloud Armor e Cloud CDN:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backendconfig
spec:
cdn:
enabled: false
securityPolicy:
name: ""
Eliminazione di un FrontendConfig o BackendConfig
FrontendConfig
Per eliminare un FrontendConfig, segui questi passaggi:
Rimuovi il nome di FrontendConfig dall'annotazione
networking.gke.io/v1beta1.FrontendConfignel manifest Ingress.Applica il manifest Ingress modificato al tuo cluster. Ad esempio, utilizza
kubectl apply.Elimina FrontendConfig. Ad esempio, utilizza
kubectl delete frontendconfig config my-frontendconfig.
BackendConfig
Per eliminare un BackedConfig, segui questi passaggi:
Rimuovi il nome di BackendConfig dall'annotazione
cloud.google.com/backend-confignel manifest del servizio.Applica il manifest del servizio modificato al tuo cluster. Ad esempio, utilizza
kubectl apply.Elimina il BackendConfig. Ad esempio, utilizza
kubectl delete backendconfig my-backendconfig.
Risoluzione dei problemi
Puoi rilevare le configurazioni errate comuni utilizzando lo strumento di diagnostica di Ingress. Devi inoltre assicurarti che tutti i controlli di integrità siano configurati correttamente.
BackendConfig non trovato
Questo errore si verifica quando nell'annotazione di servizio viene specificato un BackendConfig per una porta di servizio, ma non è stato possibile trovare la risorsa BackendConfig effettiva.
Per valutare un evento Kubernetes, esegui questo comando:
kubectl get event
L'output di esempio seguente indica che la risorsa BackendConfig non è stata trovata:
KIND ... SOURCE
Ingress ... loadbalancer-controller
MESSAGE
Error during sync: error getting BackendConfig for port 80 on service "default/my-service":
no BackendConfig for service port exists
Per risolvere il problema, assicurati di non aver creato la risorsa BackendConfig nello spazio dei nomi errato o di non aver digitato in modo errato il riferimento nell'annotazione di servizio.
Policy di sicurezza in entrata non trovata
Dopo aver creato l'oggetto Ingress, se la policy di sicurezza non è associata correttamente al servizio LoadBalancer, valuta l'evento Kubernetes per verificare se è presente un errore di configurazione. Se BackendConfig specifica una policy di sicurezza che non esiste, viene emesso periodicamente un evento di avviso.
Per valutare un evento Kubernetes, esegui questo comando:
kubectl get event
L'output di esempio seguente indica che la policy di sicurezza non è stata trovata:
KIND ... SOURCE
Ingress ... loadbalancer-controller
MESSAGE
Error during sync: The given security policy "my-policy" does not exist.
Per risolvere il problema, specifica il nome corretto della policy di sicurezza nel tuo BackendConfig.
Risoluzione degli errori della serie 500 con i NEG durante la scalabilità dei workload in GKE
Sintomo:
Quando utilizzi i NEG di cui è stato eseguito il provisioning da GKE per il bilanciamento del carico, potresti riscontrare errori 502 o 503 per i servizi durante lo fare lo scale down del workload. Gli errori 502 si verificano quando i pod vengono terminati prima della chiusura delle connessioni esistenti, mentre gli errori 503 si verificano quando il traffico viene indirizzato ai pod eliminati.
Questo problema può interessare i cluster se utilizzi prodotti di bilanciamento del carico gestiti da GKE che utilizzano NEG, tra cui Gateway, Ingress e NEG autonomi. Se scali spesso i tuoi workload, il tuo cluster corre un rischio maggiore di essere interessato.
Diagnosi:
La rimozione di un pod in Kubernetes senza prima svuotare il relativo endpoint e rimuoverlo dal NEG genera errori della serie 500. Per evitare problemi durante la terminazione dei pod, devi considerare l'ordine delle operazioni. Le seguenti immagini mostrano gli scenari in cui BackendService Drain Timeout non è impostato e BackendService Drain Timeout è impostato con BackendConfig.
Scenario 1: BackendService Drain Timeout non è impostato.
L'immagine seguente mostra uno scenario in cui BackendService Drain Timeout non è impostato.

Scenario 2: BackendService Drain Timeout è impostato.
L'immagine seguente mostra uno scenario in cui è impostato BackendService Drain Timeout.

Il momento esatto in cui si verificano gli errori della serie 500 dipende dai seguenti fattori:
Latenza di scollegamento dell'API NEG: la latenza di scollegamento dell'API NEG rappresenta il tempo corrente impiegato per finalizzare l'operazione di scollegamento in Google Cloud. Questo è influenzato da una serie di fattori esterni a Kubernetes, tra cui il tipo di bilanciatore del carico e la zona specifica.
Latenza di svuotamento: la latenza di svuotamento è il tempo impiegato dal bilanciatore del carico per iniziare a indirizzare il traffico lontano da una parte specifica del sistema. Dopo l'avvio dello svuotamento, il bilanciatore del carico smette di inviare nuove richieste all'endpoint, ma esiste comunque una latenza nell'attivazione dello svuotamento (latenza di svuotamento) che può causare errori 503 temporanei se il pod non esiste più.
Configurazione del controllo di integrità: soglie di controllo di integrità più sensibili riducono la durata degli errori 503, in quanto possono segnalare al bilanciatore del carico di interrompere l'invio di richieste agli endpoint anche se l'operazione di scollegamento non è terminata.
Periodo di tolleranza per la terminazione: il periodo di tolleranza per la terminazione determina il tempo massimo concesso a un pod per uscire. Tuttavia, un pod può uscire prima del completamento del periodo di tolleranza per la terminazione. Se un pod impiega più tempo di questo periodo, viene forzato a uscire al termine del periodo. Si tratta di un'impostazione del pod che deve essere configurata nella definizione del workload.
Possibile risoluzione:
Per evitare questi errori 5XX, applica le seguenti impostazioni. I valori di timeout sono indicativi e potrebbe essere necessario modificarli in base alla tua applicazione specifica. La sezione seguente illustra il processo di personalizzazione.
L'immagine seguente mostra come mantenere attivo il pod con un hook preStop:

Per evitare errori della serie 500, segui questi passaggi:
Imposta il valore di
BackendService Drain Timeoutper il tuo servizio su 1 minuto.Per gli utenti di Ingress, consulta Imposta il timeout su BackendConfig.
Per gli utenti di Gateway, consulta Configura il timeout su GCPBackendPolicy.
Per chi gestisce i propri servizi di backend direttamente quando utilizza NEG autonomi, consulta Imposta il timeout direttamente sul servizio di backend.
Estendi il
terminationGracePeriodsul pod.Imposta
terminationGracePeriodSecondssul pod su 3,5 minuti. Se combinata con le impostazioni consigliate, questa opzione consente ai pod di avere un intervallo di 30-45 secondi per un arresto normale dopo la rimozione dell'endpoint del pod dal NEG. Se hai bisogno di più tempo per l'arresto normale, puoi estendere il periodo di tolleranza o seguire le istruzioni riportate nella sezione Personalizza i timeout.Il seguente manifest del pod specifica un timeout di svuotamento della connessione di 210 secondi (3,5 minuti):
spec: terminationGracePeriodSeconds: 210 containers: - name: my-app ... ...Applica un hook
preStopa tutti i container.Applica un hook
preStopche garantisca che il pod rimanga attivo per altri 120 secondi mentre l'endpoint del pod viene svuotato nel bilanciatore del carico e l'endpoint viene rimosso dal NEG.spec: containers: - name: my-app ... lifecycle: preStop: exec: command: ["/bin/sh", "-c", "sleep 120s"] ...
Personalizza i timeout
Per garantire la continuità del pod ed evitare errori della serie 500, il pod deve essere attivo finché l'endpoint non viene rimosso dal NEG. In particolare, per evitare errori 502 e 503, valuta la possibilità di implementare una combinazione di timeout e un hook preStop.
Per mantenere attivo il pod più a lungo durante il processo di arresto, aggiungi un hook preStop al pod. Esegui l'hook preStop prima che un pod riceva il segnale di uscita, in modo che l'hook preStop possa essere utilizzato per mantenere attivo il pod fino a quando l'endpoint corrispondente non viene rimosso dal NEG.
Per estendere la durata di un pod attivo durante il processo di arresto,
inserisci un hook preStop nella configurazione del pod come segue:
spec:
containers:
- name: my-app
...
lifecycle:
preStop:
exec:
command: ["/bin/sh", "-c", "sleep <latency time>"]
Puoi configurare i timeout e le impostazioni correlate per gestire l'arresto normale dei pod durante lo scale down dei workload. Puoi regolare i timeout in base a casi d'uso specifici. Ti consigliamo di iniziare con timeout più lunghi e di ridurre la durata in base alle esigenze. Puoi personalizzare i timeout configurando i parametri relativi al timeout e l'hook preStop nei seguenti modi:
Timeout di svuotamento del servizio di backend
Il parametro Backend Service Drain Timeout non è impostato per impostazione predefinita e non ha alcun effetto. Se imposti il parametro Backend Service Drain Timeout e lo attivi, il bilanciatore del carico interrompe il routing delle nuove richieste all'endpoint e attende il timeout prima di terminare le connessioni esistenti.
Puoi impostare il parametro Backend Service Drain Timeout utilizzando
BackendConfig con Ingress, GCPBackendPolicy con Gateway o manualmente su
BackendService con NEG autonomi. Il timeout deve essere da 1,5 a 2 volte
superiore al tempo necessario per elaborare una richiesta. In questo modo, se una richiesta è arrivata subito prima dell'avvio dello svuotamento, verrà completata prima del timeout. Se imposti il parametro Backend Service Drain Timeout su un valore maggiore di 0, puoi ridurre gli errori 503 perché non vengono inviate nuove richieste agli endpoint pianificati per la rimozione. Affinché questo timeout sia efficace, devi utilizzarlo con l'hook preStop per assicurarti che il pod rimanga attivo durante lo svuotamento. Senza questa combinazione, le richieste esistenti che non sono state completate riceveranno un errore 502.
preStop hook time
Il hook preStop deve ritardare l'arresto del pod in modo sufficiente per completare sia la latenza di svuotamento sia il timeout di svuotamento del servizio di backend, per garantire un corretto svuotamento della connessione e la rimozione dell'endpoint dal NEG prima dell'arresto del pod.
Per ottenere risultati ottimali, assicurati che il tempo di esecuzione dell'hook preStop sia maggiore o uguale alla somma di Backend Service Drain Timeout e della latenza di svuotamento.
Calcola il tempo di esecuzione ideale dell'hook preStop con la seguente formula:
preStop hook execution time >= BACKEND_SERVICE_DRAIN_TIMEOUT + DRAIN_LATENCY
Sostituisci quanto segue:
BACKEND_SERVICE_DRAIN_TIMEOUT: l'ora configurata perBackend Service Drain Timeout.DRAIN_LATENCY: un tempo stimato per la latenza di svuotamento. Ti consigliamo di utilizzare un minuto come stima.
Se gli errori 500 persistono, stima la durata totale dell'occorrenza e aggiungi il doppio di questo tempo alla latenza di svuotamento stimata. In questo modo, il pod ha tempo sufficiente per svuotarsi correttamente prima di essere rimosso dal servizio. Puoi modificare questo valore se è troppo lungo per il tuo caso d'uso specifico.
In alternativa, puoi stimare la tempistica esaminando il timestamp di eliminazione del pod e il timestamp di rimozione dell'endpoint dal NEG in Cloud Audit Logs.
Parametro Termination Grace Period
Devi configurare il parametro terminationGracePeriod per concedere un tempo sufficiente per il completamento dell'hook preStop e per consentire al pod di completare un arresto normale.
Per impostazione predefinita, se non viene impostato esplicitamente, il valore di terminationGracePeriod è 30 secondi.
Puoi calcolare il valore ottimale di terminationGracePeriod utilizzando la formula:
terminationGracePeriod >= preStop hook time + Pod shutdown time
Per definire terminationGracePeriod all'interno della configurazione del pod:
spec:
terminationGracePeriodSeconds: <terminationGracePeriod>
containers:
- name: my-app
...
...
NEG non trovato durante la creazione di una risorsa Ingress interna
Quando crei un Ingress interno in GKE, potrebbe verificarsi il seguente errore:
Error syncing: error running backend syncing routine: googleapi: Error 404: The resource 'projects/PROJECT_ID/zones/ZONE/networkEndpointGroups/NEG' was not found, notFound
Questo errore si verifica perché Ingress per i bilanciatori del carico delle applicazioni interni richiede gruppi di endpoint di rete (NEG) come backend.
In ambienti VPC condivisi o cluster con policy di rete abilitate, aggiungi l'annotazione cloud.google.com/neg: '{"ingress": true}' al manifest del servizio.
504 Gateway Timeout: upstream request timeout
Quando accedi a un servizio da un Ingress interno in GKE, potrebbe verificarsi il seguente errore:
HTTP/1.1 504 Gateway Timeout
content-length: 24
content-type: text/plain
upstream request timeout
Questo errore si verifica perché il traffico inviato ai bilanciatori del carico delle applicazioni interni viene gestito tramite proxy da proxy Envoy nell'intervallo di subnet solo proxy.
Per consentire il traffico dall'intervallo di subnet solo proxy, crea una regola firewall su targetPort del servizio.
Errore 400: valore non valido per il campo "resource.target"
Quando accedi a un servizio da un Ingress interno in GKE, potrebbe verificarsi il seguente errore:
Error syncing:LB_NAME does not exist: googleapi: Error 400: Invalid value for field 'resource.target': 'https://www.googleapis.com/compute/v1/projects/PROJECT_NAME/regions/REGION_NAME/targetHttpProxies/LB_NAME. A reserved and active subnetwork is required in the same region and VPC as the forwarding rule.
Per risolvere il problema, crea una subnet solo proxy.
Errore durante la sincronizzazione: errore durante l'esecuzione della routine di sincronizzazione del bilanciatore del carico: il bilanciatore del carico non esiste
Quando esegui l'upgrade del control plane di GKE o quando modifichi un oggetto Ingress, potrebbe verificarsi uno dei seguenti errori:
"Error during sync: error running load balancer syncing routine: loadbalancer
INGRESS_NAME does not exist: invalid ingress frontend configuration, please
check your usage of the 'kubernetes.io/ingress.allow-http' annotation."
Oppure:
Error during sync: error running load balancer syncing routine: loadbalancer LOAD_BALANCER_NAME does not exist:
googleapi: Error 400: Invalid value for field 'resource.IPAddress':'INGRESS_VIP'. Specified IP address is in-use and would result in a conflict., invalid
Per risolvere questi problemi, prova i seguenti passaggi:
- Aggiungi il campo
hostsnella sezionetlsdel manifest Ingress, quindi elimina l'oggetto Ingress. Attendi cinque minuti affinché GKE elimini le risorse Ingress inutilizzate. Quindi, ricrea l'Ingress. Per saperne di più, consulta Il campo hosts di un oggetto Ingress. - Ripristina le modifiche apportate all'Ingress. Poi, aggiungi un certificato utilizzando un'annotazione o un secret di Kubernetes.
Problemi noti
Impossibile attivare i reindirizzamenti HTTPS con lo schema di denominazione Ingress V1
Non puoi abilitare i reindirizzamenti HTTPS sulle risorse Ingress di GKE create su GKE 1.16.8-gke.12 e versioni precedenti. Devi ricreare l'Ingress prima di poter attivare i reindirizzamenti HTTPS, altrimenti viene creato un evento di errore e l'Ingress non si sincronizza.
Il messaggio di evento di errore è simile al seguente:
Error syncing: error running load balancer syncing routine: loadbalancer lb-name does not exist: ensureRedirectUrlMap() = error: cannot enable HTTPS Redirects with the V1 Ingress naming scheme. Please recreate your ingress to use the newest naming scheme.
Campi delle policy di sicurezza di Google Cloud Armor rimossi da BackendConfig
Esiste un problema noto per cui l'aggiornamento di una risorsa BackendConfig utilizzando l'API v1beta1 rimuove una policy di sicurezza Cloud Armor attiva dal relativo servizio.
Questo problema interessa le seguenti versioni di GKE:
- Da 1.18.19-gke.1400 a 1.18.20-gke.5099
- Da 1.19.10-gke.700 a 1.19.14-gke.299
- Da 1.20.6-gke.700 a 1.20.9-gke.899
Se non configuri Cloud Armor sulle risorse Ingress tramite BackendConfig, questo problema non influisce sui tuoi cluster.
Per i cluster GKE che configurano Cloud Armor tramite BackendConfig, è vivamente consigliato aggiornare le risorse BackendConfig solo utilizzando l'API v1. L'applicazione di un BackendConfig al tuo cluster utilizzando le risorse BackendConfig v1beta1 rimuoverà la policy di sicurezza di Cloud Armor dal servizio a cui fa riferimento.
Per mitigare questo problema, apporta aggiornamenti al tuo BackendConfig solo utilizzando l'API BackendConfig v1. La risorsa BackendConfig v1 supporta tutti gli stessi campi di v1beta1 e non apporta modifiche che provocano un errore, pertanto il campo dell'API può essere aggiornato in modo trasparente.
Sostituisci il campo apiVersion di tutti i manifest BackendConfig attivi con cloud.google.com/v1 e non utilizzare cloud.google.com/v1beta1.
Il seguente manifest di esempio descrive una risorsa BackendConfig che utilizza l'API v1:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
name: my-backend-config
spec:
securityPolicy:
name: "ca-how-to-security-policy"
Se disponi di sistemi o strumenti CI/CD che aggiornano regolarmente le risorse BackendConfig, assicurati di utilizzare il gruppo API cloud.google.com/v1 in questi sistemi.
Se il tuo BackendConfig è già stato aggiornato con l'API v1beta1, la tua policy di sicurezza di Cloud Armor potrebbe essere stata rimossa.
Puoi determinare se ciò è avvenuto eseguendo questo comando:
kubectl get backendconfigs -A -o json | jq -r '.items[] | select(.spec.securityPolicy == {}) | .metadata | "\(.namespace)/\(.name)"'
Se la risposta restituisce un output, il cluster è interessato dal problema.
L'output di questo comando restituisce un elenco di risorse BackendConfig (<namespace>/<name>) interessate dal problema. Se l'output è vuoto, significa che il tuo BackendConfig non è stato aggiornato utilizzando l'API v1beta1 da quando è stato introdotto il problema. Eventuali aggiornamenti futuri di BackendConfig devono utilizzare solo v1.
Se la policy di sicurezza di Cloud Armor è stata rimossa, puoi determinare quando è stata rimossa utilizzando la seguente query di Logging:
resource.type="gce_backend_service"
protoPayload.methodName="v1.compute.backendServices.setSecurityPolicy"
protoPayload.authenticationInfo.principalEmail:"container-engine-robot."
protoPayload.response.status = "RUNNING"
NOT protoPayload.authorizationInfo.permission:"compute.securityPolicies.use"
Se uno dei tuoi cluster è stato interessato, puoi correggere il problema eseguendo il push di un aggiornamento alla risorsa BackendConfig che utilizza l'API v1.
Esegui l'upgrade del control plane GKE a una delle seguenti versioni aggiornate che applica patch a questo problema e consente di utilizzare in sicurezza le risorse BackendConfig v1beta1:
- 1.18.20-gke.5100 e versioni successive
- 1.19.14-gke.300 e versioni successive
- 1.20.9-gke.900 e versioni successive
Passaggi successivi
GKE Ingress per il bilanciamento del carico di un singolo cluster.
Tutorial su Ingress per il deployment del routing HTTP(S) per le app GKE.
Implementa GKE Ingress con un controllo di integrità HTTP personalizzato