Utilizzo di HTTP/2 per il bilanciamento del carico con Ingress

Autopilot Standard

---

Questa pagina mostra come utilizzare gli oggetti Kubernetes Ingress e Service per configurare un Application Load Balancer esterno per usare HTTP/2 per la comunicazione con i servizi di backend.

Panoramica

Un bilanciatore del carico delle applicazioni agisce come proxy tra i client e la tua applicazione. I client possono utilizzare HTTP/1.1 o HTTP/2 per comunicare con il proxy del bilanciatore del carico. Tuttavia, la connessione dal proxy del bilanciatore del carico alla tua applicazione utilizza HTTP/1.1 per impostazione predefinita. Se l'applicazione, in esecuzione in un pod di Google Kubernetes Engine (GKE), è in grado di ricevere richieste HTTP/2, devi configurare il bilanciatore del carico esterno in modo che utilizzi HTTP/2 quando inoltra le richieste alla tua applicazione.

In questo esercizio creerai un deployment, un servizio e un Ingress. Inserisci un'annotazione cloud.google.com/app-protocols nel manifest del servizio per specificare che il bilanciatore del carico deve utilizzare HTTP/2 per comunicare con l'applicazione. Quindi, chiami il servizio e verifichi che l'applicazione abbia ricevuto una richiesta HTTP/2.

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.
  Nota: per le installazioni esistenti dell'interfaccia a riga di comando gcloud, assicurati di impostare le proprietà compute/region e compute/zone. Impostando le località predefinite, puoi evitare errori nellgcloud CLI come segue: One of [--zone, --region] must be supplied: Please specify location.

• Scopri di più sulle risorse Ingress e Service di Kubernetes.
• Scopri di più sulle limitazioni HTTP/2 per un bilanciatore del carico delle applicazioni esterno.

Crea il deployment

1. Copia il seguente manifest in un file denominato my-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: echoheaders
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: echoheaders
     template:
       metadata:
         labels:
           app: echoheaders
       spec:
         containers:
         - name: echoheaders
           image: registry.k8s.io/echoserver:1.10
           ports:
           - containerPort: 8443
   

   Questo manifest descrive un deployment con due repliche dell'applicazione web echoheaders.

2. Applica il manifest al tuo cluster:

   kubectl apply -f my-deployment.yaml
   

Nota: per assicurarti che il bilanciatore del carico possa effettuare una richiesta HTTP2 corretta al tuo backend, il backend deve essere configurato con SSL. Per ulteriori informazioni sui tipi di certificati accettati, consulta Crittografia dal bilanciatore del carico ai backend.

Crea il servizio

1. Copia il seguente manifest in un file denominato my-service.yaml:

   apiVersion: v1
   kind: Service
   metadata:
     annotations:
       cloud.google.com/app-protocols: '{"my-port":"HTTP2"}'
     name: echoheaders
     labels:
       app: echoheaders
   spec:
     type: NodePort
     ports:
     - port: 443
       targetPort: 8443
       protocol: TCP
       name: my-port
     selector:
       app: echoheaders
   

   Questo manifest descrive un servizio con le seguenti proprietà:

   • type: NodePort: specifica che si tratta di un servizio di tipo NodePort.
   • app: echoheaders: specifica che tutti i pod con questa etichetta sono membri del servizio.
   • cloud.google.com/app-protocols: specifica che my-port deve utilizzare il protocollo HTTP/2.
   • port: 443, protocol: TCP e targetPort: 8433: specifica che il traffico diretto al servizio sulla porta TCP 443 deve essere instradato alla porta TCP 8422 su uno dei pod membri.

2. Applica il manifest al tuo cluster:

   kubectl apply -f my-service.yaml
   

3. Visualizza il servizio:

   kubectl get service echoheaders --output yaml
   

   L'output è simile al seguente:

   apiVersion: v1
   kind: Service
   metadata:
     annotations:
       cloud.google.com/app-protocols: '{"my-port":"HTTP2"}'
       ...
     labels:
       app: echoheaders
     name: echoheaders
     ...
   spec:
     clusterIP: 10.39.251.148
     ...
     ports:
     - name: my-port
       nodePort: 30647
       port: 443
       protocol: TCP
       targetPort: 8443
     selector:
       app: echoheaders
     ...
     type: NodePort
   ...
   

Crea la risorsa Ingress

1. Copia il seguente manifest in un file denominato my-ingress.yaml:

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: echomap
   spec:
     defaultBackend:
       service:
         name: echoheaders
         port:
           number: 443
   

   Questo manifest descrive un Ingress che specifica che le richieste in entrata vengono inviate a un pod che è membro del servizio echoheaders. Le richieste vengono instradate al pod sul targetPort specificato nel manifest del servizio echoheaders. In questo esercizio, il pod targetPort è 8443.

2. Applica il manifest al tuo cluster:

   kubectl apply -f my-ingress.yaml
   

   Il completamento di questo comando può richiedere diversi minuti mentre il controller Kubernetes Ingress configura l'Application Load Balancer.

3. Visualizza Ingress:

   kubectl get ingress echomap --output yaml
   

   L'output è simile al seguente:

   kind: Ingress
   metadata:
     ...
     name: echomap
     ...
   spec:
     backend:
       serviceName: echoheaders
       servicePort: 443
   status:
     loadBalancer:
       ingress:
       - ip: 203.0.113.2
   

   In questo output, l'indirizzo IP della risorsa Ingress è 203.0.113.2.

Testa il bilanciatore del carico

gcloud

1. Elenca i tuoi servizi di backend:

   gcloud compute backend-services list
   

2. Descrivi il tuo servizio di backend:

   gcloud beta compute backend-services describe BACKEND_SERVICE_NAME --global
   

   Sostituisci BACKEND_SERVICE_NAME con il nome del tuo servizio di backend.

   L'output specifica che protocol è HTTP2:

   backends:
   ...
   description: '{...,"kubernetes.io/service-port":"443","x-features":["HTTP2"]}'
   ...
   kind: compute#backendService
   loadBalancingScheme: EXTERNAL
   protocol: HTTP2
   ...
   

Console

1. Vai alla pagina Bilanciamento del carico nella console Google Cloud.

   Vai a Bilanciamento del carico

2. In Nome, individua il bilanciatore del carico.

3. Fai clic sul nome del bilanciatore del carico per visualizzare il servizio di backend.

4. Verifica che il protocollo endpoint per il tuo servizio di backend sia HTTP/2.

Chiama il servizio

Attendi qualche minuto per consentire a GKE di configurare il bilanciatore del carico e il servizio di backend, quindi inserisci l'indirizzo IP esterno del bilanciatore del carico nella barra degli indirizzi del browser.

L'output è simile al seguente:

Hostname: echoheaders-7886d5bc68-xnrwj
...
Request Information:
  ...
  method=GET
  real path=/
  query=
  request_version=2
  request_scheme=https
  ...

Request Headers:
  ...
  x-forwarded-for=[YOUR_IP_ADDRESS], 203.0.113.2
  x-forwarded-proto=http
...

Queste informazioni di output sulla richiesta dal bilanciatore del carico al pod:

• request_version=2: indica che la richiesta tra il bilanciatore del carico e il pod ha utilizzato HTTP/2.
• x-forwarded-proto=http: indica che la richiesta tra il browser e il bilanciatore del carico utilizzava HTTP 1.1, non HTTP/2.

Passaggi successivi

• Configura un Application Load Balancer esterno con Ingress.

• Configura un indirizzo IP statico e un nome di dominio per la tua applicazione utilizzando Ingress.

• Configura i certificati SSL per il bilanciatore del carico Ingress.