HTTP/2 pour l'équilibrage de charge avec l'objet "Entrée"

Cette page décrit comment utiliser les objets Kubernetes Entrée et Service pour configurer un équilibreur de charge HTTP(S) afin qu'il utilise HTTP/2 pour communiquer avec les services de backend. Cette fonctionnalité est disponible à partir de la version 1.11.2 de Google Kubernetes Engine.

Aperçu

Un équilibreur de charge HTTP(S) joue le rôle de 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, qui s'exécute dans un pod Kubernetes Engine, est capable de recevoir des requêtes HTTP/2, vous pouvez configurer l'équilibreur de charge pour qu'il utilise HTTP/2 lorsqu'il transmet des requêtes à votre application.

Schéma montrant HTTP/2 entre l'équilibreur de charge et le pod (cliquez pour agrandir)

Dans cet exercice, vous allez créer un déploiement, un service et une entrée. Vous insérerez une annotation cloud.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

Pour préparer ce que nous allons réaliser, procédez comme suit :

  • Assurez-vous d'avoir activé l'API Google Kubernetes Engine.
  • Activer l'API Google Kubernetes Engine
  • Assurez-vous d'avoir installé le SDK Cloud.
  • Définissez votre ID de projet par défaut :
    gcloud config set project [PROJECT_ID]
  • Si vous utilisez des clusters zonaux, définissez votre zone de calcul par défaut :
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Si vous utilisez des clusters régionaux, définissez votre région de calcul par défaut :
    gcloud config set compute/region [COMPUTE_REGION]
  • Installez la dernière mise à jour de gcloud :
    gcloud components update
  • Documentez-vous sur les ressources Entrée et Service de Kubernetes.

Créer le déploiement

Ce fichier manifeste de déploiement déclare que vous souhaitez exécuter deux instances dupliquées de l'application Web echoheaders :

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: echoheaders
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: echoheaders
    spec:
      containers:
      - name: echoheaders
        image: k8s.gcr.io/echoserver:1.10
        ports:
        - containerPort: 8443

Copiez le fichier manifeste dans un fichier nommé my-deployment.yaml et créez le déploiement :

kubectl apply -f my-deployment.yaml

Créer le service

Voici un fichier manifeste pour le service :

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

Enregistrez le fichier manifeste dans un fichier nommé my-service.yaml et créez le service :

kubectl apply -f my-service.yaml

Consultez le Service :

kubectl get service echoheaders --output yaml

Le résultat est semblable à ceci :

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

Pour les besoins de cet exercice, voici les points importants à noter à propos de votre service :

  • Le service possède le type NodePort. Ce type est obligatoire pour les services qui vont être associés à une entrée.

  • Tout pod comportant le libellé app: echoheaders est membre du service. Le champ selector spécifie ceci.

  • Le service dispose d'un port qui est nommé my-port. L'annotation cloud.google.com/app-protocols indique que my-port doit utiliser le protocole HTTP/2.

  • Le trafic dirigé vers le service sur le port TCP 443 est acheminé vers le port TCP 8443 de l'un des pods membres. Les champs port et targetPort spécifient cette réalité.

Créer l'entrée

Voici un fichier manifeste pour l'entrée :

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: echomap
spec:
  backend:
    serviceName: echoheaders
    servicePort: 443

Copiez le fichier manifeste dans un fichier nommé my-ingress.yaml et créez l'entrée :

kubectl apply -f my-ingress.yaml

Attendez quelques minutes que le contrôleur d'entrée Kubernetes configure un équilibreur de charge HTTP(S), puis affichez l'entrée :

kubectl get ingress echomap --output yaml

Le résultat est semblable à ceci :

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

Pour les besoins de cet exercice, voici les points importants à noter à propos de votre entrée :

  • L'adresse IP du trafic entrant est répertoriée sous loadBalancer:ingress.

  • Les requêtes entrantes sont acheminées vers un pod membre du service echoheaders. Dans cet exercice, les pods membres portent le libellé app: echoheaders.

  • Les demandes sont acheminées vers le pod sur le port cible spécifié dans le fichier manifeste du service echoheaders. Dans cet exercice, le port cible du pod est 8443.

Vérifier que votre équilibreur de charge est compatible avec le protocole HTTP/2

gcloud

  1. Affichez la liste de vos services de backend :

    gcloud compute backend-services list
    
  2. Décrivez votre service de backend :

    gcloud beta compute backend-services describe [BACKEND_SERVICE_NAME] --global
    

    où [BACKEND_SERVICE_NAME] est le nom de votre service de backend.

  3. Dans la sortie, vérifiez que le protocole est HTTP/2 :

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

Console

  1. Dans la console Google Cloud Platform, accédez à la page "Équilibrage de charge".
    Accéder à la page Équilibrage de charge

  2. Sous Name (Nom), localisez votre équilibreur de charge.

    Capture d'écran de l'équilibreur de charge HTTP affichée dans la console Google Cloud Platform (cliquez pour agrandir)
  3. Cliquez sur le nom de votre équilibreur de charge pour afficher votre service de backend.

  4. Vérifiez que le Endpoint protocol (Protocole du point de terminaison) de votre service de backend est HTTP/2.

    Capture d'écran du service de backend HTTP/2 affichée dans la console Google Cloud Platform (cliquez pour agrandir)

Appeler votre service

Attendez quelques minutes que l'équilibreur de charge et le service de backend soient configurés. Saisissez l'adresse IP externe de votre équilibreur de charge dans la barre d'adresse de votre navigateur.

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

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

Pour les besoins de cet exercice, voici les points importants à noter concernant le résultat précédent :

  • La ligne request_version=2 indique que la requête entre l'équilibreur de charge et le pod a utilisé HTTP/2.

  • La ligne x-forwarded-proto=http indique que la requête entre vous et l'équilibreur de charge a utilisé HTTP 1.1 et non HTTP/2.

Et ensuite ?

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation Kubernetes Engine