Utiliser HTTP/2 pour l'équilibrage de charge avec Ingress

Autopilot Standard

Cette page explique comment utiliser les objets Kubernetes Ingress et Service pour configurer un équilibreur de charge d'application externe de manière à utiliser HTTP/2 pour la communication avec les services de backend.

Présentation

Un équilibreur de charge d'application agit comme un proxy entre vos clients et votre application. Les clients peuvent utiliser HTTP/1.1 ou HTTP/2 pour communiquer avec le proxy de l'équilibreur de charge. Cependant, la connexion entre le proxy de l'équilibreur de charge et votre application utilise le protocole HTTP/1.1 par défaut. Si votre application exécutée dans un pod Google Kubernetes Engine (GKE) peut recevoir des requêtes HTTP/2, configurez l'équilibreur de charge externe pour qu'il utilise HTTP/2 lorsqu'il transmet des requêtes à votre application.

Dans cet exercice, vous allez créer un déploiement, un service et une entrée. Vous insérerez une annotationcloud.google.com/app-protocols dans le fichier manifeste du service pour indiquer que l'équilibreur de charge doit utiliser HTTP/2 pour communiquer avec votre application. Ensuite, vous appellerez votre service et vérifierez que votre application a bien reçu une requête HTTP/2.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Documentez-vous sur les ressources Ingress et Service de Kubernetes.
Découvrez les limitations du protocole HTTP/2 pour un équilibreur de charge d'application externe.

Créer le déploiement

Copiez le fichier manifeste suivant dans un fichier nommé 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

Ce fichier manifeste décrit un déploiement avec deux instances répliquées de l'application Web echoheaders.

Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f my-deployment.yaml
```

Créer le service

Copiez le fichier manifeste suivant dans un fichier nommé 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
```
Ce fichier manifeste décrit un service avec les propriétés suivantes :
- type: NodePort : indique qu'il s'agit d'un service de type NodePort.
- app: echoheaders : indique que tout pod portant cette étiquette est membre du service.
- cloud.google.com/app-protocols : indique que my-port doit utiliser le protocole HTTP/2.
- port: 443, protocol: TCP et targetPort: 8433 : indique que le trafic envoyé au service sur le port TCP 443 doit être acheminé vers le port TCP 8422 sur l'un des pods membres.
Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f my-service.yaml
```

Consultez le Service :

kubectl get service echoheaders --output yaml

Le résultat ressemble à ce qui suit :

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
...

Créer l'Ingress

Copiez le fichier manifeste suivant dans un fichier nommé my-ingress.yaml :
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: echomap
spec:
  defaultBackend:
    service:
      name: echoheaders
      port:
        number: 443
```
Ce fichier manifeste décrit un Ingress qui spécifie que les requêtes entrantes sont envoyées à un pod membre du service echoheaders. Les requêtes sont acheminées vers le pod sur le port targetPort spécifié dans le fichier manifeste du service echoheaders. Dans cet exercice, le pod targetPort est 8443.
Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f my-ingress.yaml
```
L'exécution de cette commande peut prendre plusieurs minutes lorsque le contrôleur d'entrée Kubernetes configure l'équilibreur de charge d'application.

Affichez l'objet Entrée :

kubectl get ingress echomap --output yaml

Le résultat ressemble à ce qui suit :

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

Dans cette sortie, l'adresse IP de l'Ingress est 203.0.113.2.

Tester l'équilibreur de charge

gcloud

Affichez la liste de vos services de backend :
```
gcloud compute backend-services list
```

Décrivez votre service de backend :

gcloud beta compute backend-services describe BACKEND_SERVICE_NAME --global

Remplacez BACKEND_SERVICE_NAME par le nom de votre service de backend.

La sortie indique que la valeur de protocol est HTTP2 :

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

Console

Accédez à la page Équilibrage de charge dans Google Cloud Console.

Accéder à la page "Équilibrage de charge"
Sous Name (Nom), localisez votre équilibreur de charge.
Cliquez sur le nom de votre équilibreur de charge pour afficher votre service de backend.
Vérifiez que le protocole du point de terminaison de votre service de backend est HTTP/2.

Appeler votre service

Attendez quelques minutes que GKE configure l'équilibreur de charge et le service de backend, puis saisissez l'adresse IP externe de votre équilibreur de charge dans la barre d'adresse de votre navigateur.

Le résultat ressemble à ce qui suit :

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
...

Cette sortie affiche des informations au sujet de la requête de l'équilibreur de charge au pod :

request_version=2 : indique que la requête entre l'équilibreur de charge et le pod a utilisé HTTP/2.
x-forwarded-proto=http : indique que la requête entre le navigateur et l'équilibreur de charge a utilisé HTTP 1.1 et non HTTP/2.

Étapes suivantes

Configurez un équilibreur de charge d'application externe avec un Ingress.
Configurez une adresse IP statique et un nom de domaine pour votre application à l'aide d'un Ingress.
Configurez des certificats SSL pour votre équilibreur de charge avec l'objet "Entrée".