Intégrer l'équilibrage de charge HTTP(S) à Cloud Run pour Anthos sur Google Cloud

Ce tutoriel explique comment utiliser l'équilibrage de charge HTTP(S) avec les services Cloud Run pour Anthos sur Google Cloud au lieu de l'équilibrage de charge réseau pour exposer des services sur Internet.

L'équilibrage de charge HTTP(S) fournit un équilibrage de charge global et s'intègre à un certain nombre de produits et fonctionnalités Google Cloud tels que Google Cloud Armor, Cloud CDN, Identity-Aware Proxy (IAP) ainsi que des certificats TLS gérés pour le trafic HTTPS.

Passerelles d'entrée Kubernetes et Istio

Ce tutoriel utilise conjointement deux concepts de même nature. Si vous appliquez ce tutoriel, assurez-vous de bien comprendre les différences suivantes :

  • La passerelle d'entrée Istio définit les règles de routage du trafic HTTP/TCP externe vers les services d'un cluster Kubernetes. Elle est mise en œuvre sous la forme d'un service Kubernetes et d'un déploiement Kubernetes.
  • La passerelle d'entrée Kubernetes définit les règles de routage du trafic HTTP externe vers un ou plusieurs services Kubernetes dans un cluster. Lorsque vous créez un objet Entrée Kubernetes dans un cluster GKE, GKE provisionne les ressources nécessaires pour l'équilibrage de charge HTTP.

Dans ce tutoriel, vous allez utiliser une ressource Entrée Kubernetes pour acheminer le trafic externe vers la passerelle d'entrée Istio. Celle-ci achemine ensuite le trafic vers les services du cluster, comme illustré dans le schéma ci-dessous.

Schéma montrant comment le trafic HTTP/TCP externe est acheminé.

Vous pouvez utiliser la passerelle d'entrée Istio pour acheminer le trafic vers plusieurs services au sein du même cluster GKE.

Objectifs

  • Créer un cluster GKE avec Cloud Run activé
  • Créer un service virtuel Istio pour gérer les requêtes de vérification d'état.
  • Modifier l'objet Service Kubernetes de la passerelle d'entrée Istio pour qu'il puisse être exposé par un objet Entrée Kubernetes.
  • Configurer l'équilibrage de charge HTTP en créant un objet Entrée Kubernetes.
  • Déployer un exemple de service pour valider la solution.

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la page Effectuer un nettoyage pour en savoir plus.

Avant de commencer

  1. Sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  2. Activez la facturation pour votre projet Cloud.

  3. Activez les GKE, Cloud Run, and Google Cloud requises.

    Activer les API

  4. Dans Cloud Console, ouvrez Cloud Shell.

    Ouvrir Cloud Shell

    En bas de la fenêtre de Cloud Console, une session Cloud Shell s'ouvre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel le SDK Cloud est déjà installé (y compris l'outil de ligne de commande gcloud), et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

    Utilisez Cloud Shell pour exécuter toutes les commandes de ce tutoriel.

Créer un cluster GKE avec Cloud Run

  • Créez un cluster GKE avec le module complémentaire Cloud Run :

    CLUSTER=cloudrun-gke-gclb-tutorial
    ZONE=us-central1-f
    
    gcloud beta container clusters create $CLUSTER \
        --addons HorizontalPodAutoscaling,HttpLoadBalancing,CloudRun \
        --enable-ip-alias \
        --enable-stackdriver-kubernetes \
        --machine-type n1-standard-2 \
        --zone $ZONE
    

    Ce tutoriel utilise cloudrun-gke-gclb-tutorial comme nom de cluster et us-central1-f comme zone. Vous pouvez modifier ces valeurs. Pour plus d'informations, consultez la page Zones géographiques et régions.

    Pour comprendre les options de la commande, examinez les points suivants :

    • Le module complémentaire HttpLoadBalancing permet aux objets Ingress Kubernetes de configurer l'équilibrage de charge HTTP(S) pour le cluster.

    • L'option --enable-ip-alias rend le cluster VPC natif. Cette option est obligatoire si vous souhaitez utiliser l'équilibrage de charge natif en conteneurs appliqué dans ce tutoriel.

    • L'option --enable-stackdriver-kubernetes agrège les journaux, les événements et les métriques du cluster à l'aide de la suite des opérations Google Cloud pour GKE. Cette option est requise par le module complémentaire Cloud Run.

Gérer les requêtes de vérification d'état

  • Créez un service virtuel Istio, qui permet au cluster de répondre aux requêtes de vérification d'état de l'équilibrage de charge en les transmettant au point de terminaison de l'état sur la passerelle d'entrée Istio.

    Notez que le service virtuel que vous créez est associé à la ressource de la passerelle Istio gke-system-gateway, installée par le module complémentaire CloudRun.

    kubectl apply -f - <<EOF
    apiVersion: networking.istio.io/v1alpha3
    kind: VirtualService
    metadata:
      name: health
      namespace: knative-serving
    spec:
      gateways:
      - gke-system-gateway
      hosts:
      - "*"
      http:
      - match:
        - headers:
            user-agent:
              prefix: GoogleHC
          method:
            exact: GET
          uri:
            exact: /
        rewrite:
          authority: istio-ingress.gke-system.svc.cluster.local:15020
          uri: /healthz/ready
        route:
        - destination:
            host: istio-ingress.gke-system.svc.cluster.local
            port:
              number: 15020
    EOF
    

Modifier la passerelle d'entrée Istio à utiliser avec un objet Entrée Kubernetes

  1. Créez un fichier de correctif JSON pour apporter des modifications à la passerelle d'entrée Istio :

    cat <<EOF > istio-ingress-patch.json
    [
      {
        "op": "replace",
        "path": "/spec/type",
        "value": "NodePort"
      },
      {
        "op": "remove",
        "path": "/status"
      }
    ]
    EOF
    
  2. Appliquez le fichier correctif et ajoutez la passerelle d'entrée Istio en tant que backend:

    kubectl -n gke-system patch svc istio-ingress \
        --type=json -p="$(cat istio-ingress-patch.json)" \
        --dry-run=true -o yaml | kubectl apply -f -
    kubectl annotate svc istio-ingress -n gke-system cloud.google.com/neg='{"exposed_ports": {"80":{}}}'
    

    Ce correctif apporte les modifications suivantes à l'objet Service Kubernetes de la passerelle d'entrée Istio :

Créer un objet Entrée Kubernetes

  1. Créez un objet Entrée Kubernetes appelé my-ingress :

    kubectl apply -f - <<EOF
    apiVersion: extensions/v1beta1
    kind: Ingress
    metadata:
      name: my-ingress
      namespace: gke-system
    spec:
      backend:
        serviceName: istio-ingress
        servicePort: 80
    EOF
    

    Cet objet Ingress envoie tout le trafic entrant vers le service Kubernetes istio-ingress dans l'espace de noms gke-system.

    Lorsque vous créez un objet Entrée Kubernetes dans un cluster GKE, GKE crée les ressources nécessaires pour l'équilibrage de charge HTTP(S).

  2. Observez la progression de la commande précédente et attendez que my-ingress ADDRESS devienne une adresse IP :

    kubectl get ingress my-ingress -n gke-system --watch
    

    Pour arrêter l'attente, appuyez sur Control+C.

  3. Créez une variable d'environnement pour stocker l'adresse IP de l'objet Entrée Kubernetes :

    INGRESS_IP=$(kubectl get ingress my-ingress -n gke-system \
        --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
    

Déployer un service et valider la solution

  1. Déployez un exemple de service appelé my-service sur Cloud Run pour Anthos sur Google Cloud :

    gcloud run deploy my-service \
        --namespace default \
        --image gcr.io/knative-samples/simple-api \
        --platform gke \
        --cluster $CLUSTER \
        --cluster-location $ZONE
    

    Quelques instants peuvent s'écouler avant que l'équilibrage de charge HTTP(S) soit prêt à acheminer le trafic après la création de l'objet Entrée Kubernetes. En attendant, vous pouvez recevoir des erreurs telles que HTTP/1.1 404 Not Found ou HTTP/1.1 502 Bad Gateway lorsque vous envoyez des requêtes aux services du cluster.

  2. Envoyez une requête HTTP GET à l'exemple de service toutes les deux secondes :

    while sleep 2; do
      curl -siH "Host: my-service.default.example.com" $INGRESS_IP | head -n1
    done
    

    Surveillez la sortie jusqu'à ce que les éléments suivants s'affichent :

    HTTP/1.1 200 OK
    

    Pour arrêter l'envoi de demandes, appuyez sur Control+C.

  3. Envoyez une requête HTTP GET à l'exemple de service :

    curl -s -w"\n" -H "Host: my-service.default.example.com" $INGRESS_IP
    

    Le résultat est le suivant :

    OK
    

Dépannage

Si vous rencontrez des problèmes avec ce tutoriel, consultez les documents ci-dessous :

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud, vous pouvez supprimer le projet Cloud que vous avez créé pour ce tutoriel ou supprimer les ressources associées.

Supprimer le projet Cloud

Le moyen le plus simple d'éviter la facturation consiste à supprimer le projet Cloud que vous avez créé pour le tutoriel.

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer .
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer les ressources

Si vous souhaitez conserver le projet Cloud que vous avez utilisé dans ce tutoriel, supprimez le cluster GKE :

```
gcloud container clusters delete $CLUSTER --zone $ZONE --async --quiet
```

Étape suivante