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

Autopilot Standard

---

Questa pagina mostra come utilizzare Kubernetes In entrata e Servizio oggetti per configurare un bilanciatore del carico delle applicazioni esterno da utilizzare HTTP/2 per la comunicazione con i servizi di backend.

Panoramica

Un bilanciatore del carico delle applicazioni agisce come proxy tra i client e l'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 all'applicazione utilizza HTTP/1.1 per impostazione predefinita. Se la tua applicazione, in esecuzione in un pod Google Kubernetes Engine (GKE), è in grado di ricevere richieste HTTP/2, configura 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 file manifest del servizio per specificare che il bilanciatore del carico deve utilizzare HTTP/2 per comunicare con la tua 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à:

• Attiva l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, installa e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo gcloud components update.
  Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare le proprietà compute/region e compute/zone. Se imposti località predefinite, puoi evitare errori in gcloud CLI come i seguenti: One of [--zone, --region] must be supplied: Please specify location.

• Scopri di più sulle risorse Kubernetes Ingress e Service.
• Scopri le limitazioni di 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 del echoheaders applicazione web.

2. Applica il manifest al 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 la sezione 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 qualsiasi pod con questa etichetta è un membro 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 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 l'elemento 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 arrivo vengono inviate a un pod che è membro del servizio echoheaders. Le richieste sono instradato al pod su targetPort specificato in echoheaders Manifest del servizio. In questo esercizio, il pod targetPort è 8443.

2. Applica il manifest al cluster:

   kubectl apply -f my-ingress.yaml
   

   Il completamento di questo comando può richiedere diversi minuti mentre Il controller in entrata configura il bilanciatore del carico delle applicazioni.

3. Visualizza l'elemento 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 del traffico in entrata è 203.0.113.2.

Testa il bilanciatore del carico

gcloud

1. Elenca i servizi di backend:

   gcloud compute backend-services list
   

2. Descrivi il servizio di backend:

   gcloud beta compute backend-services describe BACKEND_SERVICE_NAME --global
   

   Sostituisci BACKEND_SERVICE_NAME con il nome di e il 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 tuo 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 affinché GKE configuri il bilanciatore del carico di servizio di backend, quindi inserisci l'indirizzo IP esterno del bilanciatore del carico 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 Pod:

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

Passaggi successivi

• Imposta un Application Load Balancer esterno con Ingress.

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

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