Intégrer IAP avec Anthos Service Mesh

Ce tutoriel explique comment intégrer Identity-Aware Proxy (IAP) à Anthos Service Mesh. L'intégration d'IAP à Anthos Service Mesh vous permet d'accéder en toute sécurité aux services conformément aux principes de BeyondCorp de Google. IAP vérifie l'identité de l'utilisateur et le contexte de la requête pour déterminer si cet utilisateur doit être autorisé à accéder à une application ou à une ressource. L'intégration d'IAP à Anthos Service Mesh offre les avantages suivants :

  • Contrôle complet de l'accès contextuel aux charges de travail exécutées sur Anthos Service Mesh. Vous pouvez définir des règles d'accès précises en fonction d'attributs de la requête d'origine, tels que l'identité de l'utilisateur, l'adresse IP et le type d'appareil. Vous pouvez combiner vos règles d'accès avec des restrictions basées sur le nom d'hôte et le chemin d'une URL de requête.

  • Activez la compatibilité des revendications contextuelles dans l'autorisation Anthos Service Mesh.

  • Accès évolutif, sécurisé et hautement disponible à votre application via un équilibreur de charge Google Cloud. L'équilibrage de charge hautes performances offre une protection intégrée contre les attaques par déni de service distribué (DDoS) et une compatibilité avec l'adressage IP Anycast.

Objectifs

  • Configuration :
    1. Configurez votre projet Google Cloud pour accorder les autorisations et activer les API Google requises par IAP.
    2. Réservez une adresse IP statique externe et configurez un nom de domaine pour utiliser l'adresse IP dont l'équilibreur de charge a besoin.
    3. Configurez un nouveau cluster Google Kubernetes Engine (GKE) avec les options requises pour intégrer IAP à Anthos Service Mesh.
    4. Installez Anthos Service Mesh avec les options requises pour l'intégration.
    5. Déployez un exemple d'application.
    6. Déployez l'équilibreur de charge.

  • Activez IAP.

  • Activez la compatibilité du jeton RCToken sur le maillage de services.

Coûts

Dans ce document, vous utilisez 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é les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Conditions requises

  • Vous devez disposer d'une licence d'essai ou d'un abonnement Anthos. Pour en savoir plus, consultez le guide des tarifs Anthos.

  • Votre cluster GKE doit répondre aux exigences suivantes :

    • Au moins quatre nœuds.
    • Le type de machine minimal est e2-standard-4, qui comporte quatre processeurs virtuels.
    • Utilisez une version disponible plutôt qu'une version statique de GKE.

  • Pour être inclus dans le maillage de services, les ports de service doivent être nommés et le nom de protocole du port doit respecter la syntaxe suivante : name: protocol[-suffix], où les crochets indiquent un suffixe facultatif qui doit commencer par un tiret. Pour en savoir plus, consultez la section Attribuer des noms aux ports du service.

  • Si vous installez Anthos Service Mesh sur un cluster privé et que vous souhaitez utiliser l'injection side-car automatique, vous devez ajouter une règle de pare-feu pour ouvrir le port 15017. Si vous n'ajoutez pas la règle de pare-feu et que l'injection side-car automatique est activée, le déploiement des charges de travail génère une erreur. Pour plus d'informations sur l'ajout d'une règle de pare-feu, consultez la section Ajouter des règles de pare-feu pour des cas d'utilisation spécifiques.

  • Si vous avez créé un périmètre de service dans votre organisation, vous devrez peut-être ajouter le service Mesh CA au périmètre. Pour en savoir plus, consultez la section Ajouter l'autorité de certification Mesh CA à un périmètre de service.

Configurer votre environnement

Pour les installations sur Google Kubernetes Engine, vous pouvez suivre les guides d'installation via Cloud Shell, une interface de ligne de commande intégrée au navigateur vers vos ressources Google Cloud, ou votre propre ordinateur fonctionnant sous Linux ou macOS.

Option A : Utiliser Cloud Shell

Cloud Shell provisionne une machine virtuelle (VM) g1-small Compute Engine exécutant un système d'exploitation Linux basé sur Debian. Les avantages liés à l'utilisation de Cloud Shell sont les suivants :

  • Il comprend, entre autres, les outils de ligne de commande gcloud, kubectl et helm.

  • Votre répertoire Cloud Shell $HOME dispose d'un espace de stockage persistant de 5 Go.

  • Nous vous proposons plusieurs éditeurs de texte :

    • Éditeur de code, auquel vous accédez en cliquant sur en haut de la fenêtre Cloud Shell.

    • Emacs, Vim ou Nano, auxquels vous accédez depuis la ligne de commande dans Cloud Shell.

Pour utiliser Cloud Shell, procédez comme suit :

  1. Accédez à Google Cloud Console.
  2. Sélectionnez votre projet Google Cloud.

  3. Cliquez sur le bouton Activer Cloud Shell en haut de la fenêtre de la console Google Cloud.

    Console Google Cloud Platform

    Une session Cloud Shell s'ouvre dans un nouveau cadre en bas de la console Google Cloud et affiche une invite de ligne de commande.

    Session Cloud Shell

  4. Mettez à jour les composants :

    gcloud components update

    La commande renvoie un résultat semblable à celui-ci :

    ERROR: (gcloud.components.update)
You cannot perform this action because the gcloud CLI component manager
is disabled for this installation. You can run the following command
to achieve the same result for this installation:

sudo apt-get update && sudo apt-get --only-upgrade install ...

  5. Copiez la commande longue, puis collez-la pour mettre à jour les composants.

  6. Installez kubectl :

    sudo apt-get install kubectl

  7. Installez kpt :

    sudo apt-get install google-cloud-sdk-kpt

Option B : Utiliser des outils de ligne de commande localement

Sur votre ordinateur local, installez et initialisez gcloud CLI.

  1. Authentifiez-vous avec Google Cloud CLI :

    gcloud auth login

  2. Mettez à jour les composants :

    gcloud components update

  3. Installez kubectl :

    gcloud components install kubectl

  4. Installez kpt :

    gcloud components install kpt

Configurer le projet

  1. Obtenez l'ID du projet dans lequel le cluster sera créé :

    gcloud

    gcloud projects list

    Console

    1. Dans la console Google Cloud, accédez à la page Tableau de bord:

      Accéder à la page "Tableau de bord"

    2. Cliquez sur la liste déroulante de sélection du projet située en haut de la page. Sélectionnez votre projet dans la fenêtre Sélectionnez une organisation qui vous est présentée.

      L'ID du projet est affiché sur la fiche Informations sur le projet du tableau de bord du projet.

  2. Créez une variable d'environnement pour l'ID de projet : 
    export PROJECT_ID=YOUR_PROJECT_ID
  3. Définissez l'ID de projet par défaut pour l'outil de ligne de commande gcloud : 
    gcloud config set project ${PROJECT_ID}
  4. Créez une variable d'environnement pour le numéro de projet : 
    export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")

  5. Définissez les rôles IAM (gestion de l'authentification et des accès). Si vous êtes un propriétaire de projet, vous disposez de toutes les autorisations nécessaires pour terminer l'installation et enregistrer votre cluster avec votre environnement. Si vous n'êtes pas un propriétaire de projet, quelqu'un doit vous accorder les rôles IAM spécifiques suivants. Dans la commande suivante, remplacez GCP_EMAIL_ADDRESS par le compte que vous utilisez pour vous connecter à Google Cloud. 
    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
     --member user:GCP_EMAIL_ADDRESS \
     --role=roles/editor \
     --role=roles/compute.admin \
     --role=roles/container.admin \
     --role=roles/resourcemanager.projectIamAdmin \
     --role=roles/iam.serviceAccountAdmin \
     --role=roles/iam.serviceAccountKeyAdmin \
     --role=roles/gkehub.admin

    Pour en savoir plus sur l'attribution de rôles IAM, consultez la page Accorder, modifier et révoquer les accès à des ressources. Pour obtenir une description de ces rôles, consultez la section Autorisations requises pour installer Anthos Service Mesh.

  6. Activez les API suivantes : 
    gcloud services enable \
    container.googleapis.com \
    compute.googleapis.com \
    monitoring.googleapis.com \
    logging.googleapis.com \
    cloudtrace.googleapis.com \
    meshca.googleapis.com \
    meshtelemetry.googleapis.com \
    meshconfig.googleapis.com \
    iamcredentials.googleapis.com \
    anthos.googleapis.com \
    gkeconnect.googleapis.com \
    gkehub.googleapis.com \
    cloudresourcemanager.googleapis.com \
    iap.googleapis.com

    L'activation des API peut prendre une minute ou plus. Lorsque les API sont activées, un résultat semblable au suivant s'affiche :

    Operation "operations/acf.601db672-88e6-4f98-8ceb-aa3b5725533c" finished
successfully.

Réserver une adresse IP statique et configurer le DNS

Pour intégrer Identity-Aware Proxy à Anthos Service Mesh, vous devez configurer un équilibreur de charge HTTP(S) Google Cloud qui nécessite un nom de domaine pointant vers une adresse IP statique. Vous pouvez réserver une adresse IP externe statique, qui est alors attribuée à votre projet pour une durée indéterminée, jusqu'à ce que vous la libériez explicitement.

  1. Réservez une adresse IP externe statique :

    gcloud compute addresses create example-static-ip --global

  2. Obtenez l'adresse IP statique :

    gcloud compute addresses describe example-static-ip --global

  3. Dans votre service d'enregistrement de noms de domaine, configurez un nom de domaine complet avec l'adresse IP statique. En règle générale, vous ajoutez un enregistrement A à vos paramètres DNS. Les étapes de configuration et la terminologie permettant d'ajouter un enregistrement A pour un nom de domaine complet varient selon votre service d'enregistrement de noms de domaine.

  4. Définissez le nom de domaine dans une variable d'environnement :

    export DOMAIN_NAME=YOUR_DOMAIN_NAME

    La propagation du paramètre DNS peut prendre entre 24 et 48 heures. Vous pouvez continuer à tout configurer dans ce tutoriel, mais vous ne pourrez pas tester la configuration avant que les paramètres DNS ne se propagent.

Configurer un nouveau cluster GKE

Pour configurer un nouveau cluster, procédez comme suit :

  1. Sélectionnez une zone, un type de machine et une version disponible de GKE pour le nouveau cluster. Le type de machine minimal requis par Anthos Service Mesh est n1-standard-4. Vous pouvez utiliser n'importe quelle version disponible.

    • Pour obtenir la liste des zones GCP disponibles, procédez comme suit :

      gcloud compute zones list

    • Pour obtenir une liste des types de machines :

      gcloud compute machine-types list | more

  2. Créez les variables d'environnement suivantes :

    • Définissez le nom du cluster :

      export CLUSTER_NAME=YOUR_CLUSTER_NAME

      Le nom du cluster ne doit contenir que des caractères alphanumériques minuscules et "-". Il doit également commencer par une lettre et se terminer par un caractère alphanumérique, et ne pas dépasser 40 caractères.

    • Définissez CLUSTER_LOCATION sur votre zone de cluster :

      export CLUSTER_LOCATION=YOUR_ZONE

    • Définissez le pool de charges de travail :

      export WORKLOAD_POOL=${PROJECT_ID}.svc.id.goog

    • Définissez l'ID du réseau maillé :

      export MESH_ID="proj-${PROJECT_NUMBER}"

  3. Créez le cluster avec les options requises par Anthos Service Mesh. La commande suivante crée un cluster contenant 4 nœuds de type de machine n1-standard-4, qui possède quatre processeurs virtuels. Il s'agit du type de machine minimal et du nombre de nœuds requis pour Anthos Service Mesh. Vous pouvez spécifier un autre type de machine tant qu'il possède au moins quatre processeurs virtuels. Vous pouvez également augmenter le nombre de nœuds en fonction des besoins de votre système.

    gcloud beta container clusters create ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --zone=${CLUSTER_LOCATION} \
    --machine-type=n1-standard-4 \
    --num-nodes=4 \
    --workload-pool=${WORKLOAD_POOL} \
    --enable-stackdriver-kubernetes \
    --subnetwork=default \
    --labels mesh_id=${MESH_ID} \
    --addons=HttpLoadBalancing \
    --release-channel=regular

    La commande clusters create inclut les éléments suivants :

    • workload-pool=${WORKLOAD_POOL} : active Workload Identity, la méthode recommandée pour accéder en toute sécurité aux services Google Cloud à partir d'applications GKE.

    • enable-stackdriver-kubernetes : active Cloud Monitoring et Cloud Logging sur GKE.

    • subnetwork=default : crée un sous-réseau par défaut.

    • labels mesh_id=${MESH_ID} :définit le libellé mesh_id sur le cluster, qui est nécessaire pour que les métriques s'affichent sur le tableau de bord Anthos Service Mesh de la console Google Cloud.

    • Le module complémentaire HttpLoadBalancing active un contrôleur d'équilibrage de charge HTTP (L7) pour le cluster.

    • release-channel regular : enregistre le cluster dans la version disponible regular, mais vous pouvez choisir stable si vous avez besoin d'une plus grande stabilité ou rapid si vous souhaitez essayer de nouvelles fonctionnalitées GKE (non compatibles).

Définir des identifiants et des autorisations

  1. Initialisez votre projet afin de le préparer pour l'installation. Cette commande crée, entre autres, un compte de service pour permettre aux composants Istio, tels que le proxy side-car, d'accéder en toute sécurité aux données et aux ressources du projet : 
    curl --request POST \
  --header "Authorization: Bearer $(gcloud auth print-access-token)" \
  --data '' \
  https://meshconfig.googleapis.com/v1alpha1/projects/${PROJECT_ID}:initialize

    La commande renvoie des accolades vides : {}.

    Si vous installez une nouvelle version d'Anthos Service Mesh sur ce cluster, vous n'aurez pas besoin d'exécuter à nouveau la commande, mais l'exécuter à nouveau n'affectera pas votre installation.

  2. Obtenez des identifiants d'authentification pour interagir avec le cluster: 
    gcloud container clusters get-credentials ${CLUSTER_NAME}
  3. Accordez des autorisations d'administrateur de cluster à l'utilisateur actuel. Vous avez besoin de ces autorisations pour créer les règles de contrôle d'accès basé sur les rôles (RBAC) nécessaires pour Anthos Service Mesh : 
    kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole=cluster-admin \
  --user="$(gcloud config get-value core/account)"

    Si l'erreur "cluster-admin-binding" already exists s'affiche, vous pouvez l'ignorer et continuer avec le cluster-admin-binding existant.

Enregistrer votre cluster

Vous devez enregistrer votre cluster auprès du parc du projet pour accéder à l'interface utilisateur unifiée dans la console Google Cloud. Un parc constitue un moyen unifié d'afficher et de gérer les clusters et leurs charges de travail, y compris les clusters extérieurs à Google Cloud.

Créer un compte de service et un fichier de clé Google Cloud

Un fichier JSON contenant des identifiants de compte de service est requis pour enregistrer un cluster. Pour respecter le principe du moindre privilège, nous vous recommandons de créer un compte de service distinct pour chaque cluster que vous enregistrez.

Pour créer un compte de service et un fichier de clé, procédez comme suit :

  1. Sélectionnez un nom pour le compte de service et créez une variable d'environnement pour celui-ci :

    export SERVICE_ACCOUNT_NAME=SERVICE_ACCOUNT_NAME

  2. Créez le compte de service :

    gcloud iam service-accounts create ${SERVICE_ACCOUNT_NAME}

  3. Répertoriez tous les comptes de service d'un projet pour confirmer que le compte de service a été créé :

    gcloud iam service-accounts list

  4. Liez le rôle IAM gkehub.connect au compte de service :

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
   --member="serviceAccount:${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
   --role="roles/gkehub.connect"

  5. Créez une variable d'environnement pour le chemin d'accès local à l'emplacement où vous souhaitez enregistrer le fichier JSON. Nous vous recommandons de nommer le fichier en utilisant le nom du compte de service et votre ID de projet, par exemple : /tmp/creds/${SERVICE_ACCOUNT_NAME}-${PROJECT_ID}.json

    export SERVICE_ACCOUNT_KEY_PATH=LOCAL_KEY_PATH

  6. Téléchargez le fichier JSON contenant la clé privée du compte de service :

    gcloud iam service-accounts keys create ${SERVICE_ACCOUNT_KEY_PATH} \
   --iam-account=${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com

Enregistrer le cluster

Dans la commande suivante, remplacez MEMBERSHIP_NAME par un nom qui représente de manière unique le cluster enregistré sur le Hub.

gcloud container hub memberships register MEMBERSHIP_NAME \
    --gke-cluster=${CLUSTER_LOCATION}/${CLUSTER_NAME} \
    --service-account-key-file=${SERVICE_ACCOUNT_KEY_PATH}

La commande renvoie un résultat semblable à celui-ci : 

kubeconfig entry generated for CLUSTER_NAME.
Waiting for membership to be created...done.
Created a new membership [projects/PROJECT_ID/locations/global/memberships/MEMBERSHIP_NAME] for the cluster [MEMBERSHIP_NAME]
Generating the Connect Agent manifest...
Deploying the Connect Agent on cluster [MEMBERSHIP_NAME] in namespace [gke-connect]...
Deployed the Connect Agent on cluster [MEMBERSHIP_NAME] in namespace [gke-connect].
Finished registering the cluster [MEMBERSHIP_NAME] with the Hub.

Cette clé de compte de service est stockée sous la forme d'un secret nommé creds-gcp dans l'espace de noms gke-connect.

Pour en savoir plus sur l'enregistrement des clusters, consultez la page Enregistrer un cluster dans la documentation de Connect.

Télécharger le fichier d'installation

Avant de continuer, vérifiez que le compte de service du plan de données ASM de maillage est membre du projet :

gcloud projects get-iam-policy ${PROJECT_ID} | grep -B 1 'roles/meshdataplane.serviceAgent'

Si la commande précédente ne génère aucun résultat, revenez à la section Définir les identifiants et les autorisations et exécutez la commande curl.

    Linux

  1. Téléchargez le fichier d'installation d'Anthos Service Mesh dans votre répertoire de travail actuel : 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-linux.tar.gz
  2. Téléchargez le fichier de signature et utilisez openssl pour valider la signature : 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-linux.tar.gz.1.sig
openssl dgst -verify - -signature istio-1.5.10-asm.2-linux.tar.gz.1.sig istio-1.5.10-asm.2-linux.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    La sortie attendue est Verified OK.

  3. Extrayez le contenu du fichier vers n’importe quel emplacement de votre système de fichiers. Par exemple, pour extraire le contenu vers le répertoire de travail actuel : 
    tar xzf istio-1.5.10-asm.2-linux.tar.gz

    La commande crée un répertoire d'installation dans votre répertoire de travail actuel nommé istio-1.5.10-asm.2 et contenant les éléments suivants:

    • Des exemples d'application dans samples
    • Les outils suivants dans le répertoire bin :
      • istioctl : utilisez istioctl pour installer Anthos Service Mesh.
      • asmctl : utilisez asmctl pour valider votre configuration de sécurité après avoir installé Anthos Service Mesh. (Actuellement, asmctl n'est pas compatible avec les clusters Anthos sur VMware.)

    4. macOS

  4. Téléchargez le fichier d'installation d'Anthos Service Mesh dans votre répertoire de travail actuel : 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-osx.tar.gz
  5. Téléchargez le fichier de signature et utilisez openssl pour valider la signature : 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-osx.tar.gz.1.sig
openssl dgst -sha256 -verify /dev/stdin -signature istio-1.5.10-asm.2-osx.tar.gz.1.sig istio-1.5.10-asm.2-osx.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    La sortie attendue est Verified OK.

  6. Extrayez le contenu du fichier vers n’importe quel emplacement de votre système de fichiers. Par exemple, pour extraire le contenu vers le répertoire de travail actuel : 
    tar xzf istio-1.5.10-asm.2-osx.tar.gz

    La commande crée un répertoire d'installation dans votre répertoire de travail actuel nommé istio-1.5.10-asm.2 et contenant les éléments suivants:

    • Des exemples d'application dans samples
    • Les outils suivants dans le répertoire bin :
      • istioctl : utilisez istioctl pour installer Anthos Service Mesh.
      • asmctl : utilisez asmctl pour valider votre configuration de sécurité après avoir installé Anthos Service Mesh. (Actuellement, asmctl n'est pas compatible avec les clusters Anthos sur VMware.)

    7. Windows

  7. Téléchargez le fichier d'installation d'Anthos Service Mesh dans votre répertoire de travail actuel : 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-win.zip
  8. Téléchargez le fichier de signature et utilisez openssl pour valider la signature : 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-win.zip.1.sig
openssl dgst -verify - -signature istio-1.5.10-asm.2-win.zip.1.sig istio-1.5.10-asm.2-win.zip <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    La sortie attendue est Verified OK.

  9. Extrayez le contenu du fichier vers n’importe quel emplacement de votre système de fichiers. Par exemple, pour extraire le contenu vers le répertoire de travail actuel : 
    tar xzf istio-1.5.10-asm.2-win.zip

    La commande crée un répertoire d'installation dans votre répertoire de travail actuel nommé istio-1.5.10-asm.2 et contenant les éléments suivants:

    • Des exemples d'application dans samples
    • Les outils suivants dans le répertoire bin :
      • istioctl : utilisez istioctl pour installer Anthos Service Mesh.
      • asmctl : utilisez asmctl pour valider votre configuration de sécurité après avoir installé Anthos Service Mesh. (Actuellement, asmctl n'est pas compatible avec les clusters Anthos sur VMware.)

  10. Assurez-vous d'être dans le répertoire racine de l'installation Anthos Service Mesh. 
    cd istio-1.5.10-asm.2
  11. Pour plus de commodité, ajoutez les outils du répertoire /bin à votre variable PATH : 
    export PATH=$PWD/bin:$PATH

Préparer les fichiers de configuration des ressources

Lorsque vous exécutez istioctl apply command pour installer Anthos Service Mesh, vous spécifiez -f istio-operator.yaml dans la ligne de commande. Ce fichier contient des informations sur le projet et le cluster nécessaires à l'activation des fonctionnalités de télémétrie et de sécurité de Service Mesh. Vous devez télécharger le fichier istio-operator.yaml et d'autres fichiers de configuration des ressources, et définir les informations sur le projet et le cluster.

Pour préparer les fichiers de configuration des ressources, procédez comme suit :

  1. Si ce n'est pas déjà fait, installez kpt :

    gcloud components install kpt

  2. Vous pouvez créer un répertoire pour les fichiers de configuration des ressources du package Anthos Service Mesh (facultatif). Si vous envisagez de configurer plusieurs clusters, vous pouvez utiliser le nom du cluster comme nom de répertoire.

  3. Accédez au répertoire dans lequel vous souhaitez télécharger le package Anthos Service Mesh.

  4. Téléchargez le package Anthos Service Mesh dans le répertoire de travail actuel :

    kpt pkg get \
https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git/asm@release-1.5-asm .

  5. Définissez le nom du cluster :

      kpt cfg set asm gcloud.container.cluster ${CLUSTER_NAME}

  6. Vous pouvez éventuellement personnaliser les fichiers de configuration des ressources à l'aide de setters kpt. Par défaut, ces setters utilisent les valeurs par défaut pour gcloud config. Si vous définissez les valeurs gcloud config par défaut ou si vous souhaitez modifier les valeurs, exécutez les commande "setter" suivantes :

    • Définissez l'ID du projet :

      kpt cfg set asm gcloud.core.project ${PROJECT_ID}

    • Définissez la zone ou la région par défaut :

      kpt cfg set asm gcloud.compute.location ${CLUSTER_LOCATION}

  7. Vous pouvez éventuellement vérifier les fichiers de configuration des ressources dans votre propre système de contrôle des sources, tel que Cloud Source Repositories, pour pouvoir suivre les modifications apportées aux fichiers.

Installer Anthos Service Mesh

Installez Anthos Service Mesh et définissez les options requises pour intégrer Anthos Service Mesh à IAP.

mTLS en mode PERMISSIVE

istioctl manifest apply --set profile=asm \
  -f asm/cluster/istio-operator.yaml \
  --set values.gateways.istio-ingressgateway.type=NodePort

mTLS en mode STRICT

istioctl manifest apply --set profile=asm \
  -f asm/cluster/istio-operator.yaml \
  --set values.gateways.istio-ingressgateway.type=NodePort \
  --set values.global.mtls.enabled=true

Vous spécifiez NodePort pour le sous-réseau istio-ingressgateway, qui configure {[mesh_name]} pour ouvrir un port spécifique sur le maillage de services. Cela vous permet de configurer un équilibreur de charge qui achemine le trafic envoyé à votre nom de domaine vers ce port. Les autres options permettent d'activer l'autorité de certification Anthos Service Mesh (CA).

Valider l'installation

Nous vous recommandons d'utiliser l'outil d'analyse asmctl pour valider la configuration de base de votre projet, de votre cluster et de vos charges de travail. Si un test asmctl échoue, asmctl recommande des solutions, si possible. La commande asmctl validate exécute des tests de base qui vérifient :

  1. que les API requises par Anthos Service Mesh sont activées sur le projet ;
  2. que la passerelle Istio-Ingress est correctement configurée pour appeler Mesh CA ;
  3. l'état général d'Istiod et de la passerelle Istio-Ingress.

Si vous exécutez la commande asmctl validate avec l'option facultative --with-testing-workloads, en plus des tests de base, asmctl exécute les tests de sécurité qui vérifient que :

  1. la communication TLS mutuelle (mTLS) est correctement configurée ;
  2. Mesh CA peut émettre des certificats.

Pour exécuter les tests de sécurité, asmctl déploie des charges de travail sur votre cluster dans un espace de noms de test, exécute les tests de communication mTLS, fournit les résultats et supprime l'espace de noms de test.

Pour exécuter asmctl, procédez comme suit :

  1. Assurez-vous que les identifiants gcloud application-default sont définis :

     gcloud auth application-default login

  2. Si vous ne l'avez pas déjà fait, obtenez des identifiants d'authentification pour interagir avec le cluster :

     gcloud container clusters get-credentials ${CLUSTER_NAME}

  3. Pour exécuter à la fois les tests de base et de sécurité (en supposant que istio-1.5.10-asm.2/bin) se trouve dans votre PATH), procédez comme suit :

    asmctl validate --with-testing-workloads

    Si l'opération réussit, la commande renvoie une sortie semblable à ce qui suit :

    [asmctl version 0.3.0]
Using Kubernetes context: example-project_us-central1-example-cluster
To change the context, use the --context flag
Validating enabled APIs
OK
Validating ingressgateway configuration
OK
Validating istio system
OK
Validating sample traffic
Launching example services...
Sent traffic to example service http code: 200
verified mTLS configuration
OK
Validating issued certs
OK

Déployer un exemple d'application

Avant d'activer IAP, vous avez besoin d'une application s'exécutant sur votre cluster GKE afin de vérifier que toutes les requêtes ont une identité. Ce guide utilise l'exemple de Bookinfo pour montrer comment configurer l'équilibreur de charge HTTP(S) et activer IAP.

Démarrer les services applicatifs

  1. Remplacez le répertoire par la racine de l'installation d'Anthos Service Mesh.

  2. Ajoutez un libellé à l'espace de noms default pour utiliser l'injection side-car automatique :

    kubectl label namespace default istio-injection=enabled

  3. Pour déployer l'application, procédez comme suit :

    kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml

  4. Vérifiez que tous les services bookinfo sont en cours d'exécution :

    kubectl get services

    Le résultat attendu est semblable à ceci :

    NAME                       CLUSTER-IP   EXTERNAL-IP   PORT(S)              AGE
details                    10.0.0.31            9080/TCP             6m
kubernetes                 10.0.0.1             443/TCP              7d
productpage                10.0.0.120           9080/TCP             6m
ratings                    10.0.0.15            9080/TCP             6m
reviews                    10.0.0.170           9080/TCP             6m

  5. Vérifiez que tous les pods sont en cours d'exécution :

    kubectl get pods

    Le résultat attendu est semblable à ceci :

    NAME                                        READY     STATUS    RESTARTS   AGE
details-v1-1520924117-48z17                 2/2       Running   0          6m
productpage-v1-560495357-jk1lz              2/2       Running   0          6m
ratings-v1-734492171-rnr5l                  2/2       Running   0          6m
reviews-v1-874083890-f0qf0                  2/2       Running   0          6m
reviews-v2-1343845940-b34q5                 2/2       Running   0          6m
reviews-v3-1813607990-8ch52                 2/2       Running   0          6m

  6. Vérifiez que l'application Bookinfo est en cours d'exécution :

    kubectl exec -it $(kubectl get pod -l app=ratings -o jsonpath='{.items[0].metadata.name}') -c ratings -- curl productpage:9080/productpage | grep -o "<title>.*</title>"

    Résultat attendu :

    <title>Simple Bookstore App</title>

  7. Définissez la passerelle d'entrée et le service virtuel pour l'application :

    kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml

  8. Vérifiez que la passerelle a été créée :

    kubectl get gateway

    Le résultat attendu est semblable à ceci :

    NAME                AGE
bookinfo-gateway    32s

Demandes externes

La ressource de passerelle de Bookinfo (définie dans samples/bookinfo/networking/bookinfo-gateway.yaml) utilise la valeur istio-ingressgateway préconfigurée. Rappelez-vous que lorsque vous avez déployé Anthos Service Mesh, vous avez spécifié NodePort pour istio-ingressgateway, qui ouvre un port spécifique sur le maillage de services. Tant que vous n'avez pas configuré l'équilibreur de charge, l'application Bookinfo n'est pas accessible en dehors de votre cluster GKE (par exemple, à partir d'un navigateur). Bien que les nœuds de votre cluster aient des adresses IP externes, les requêtes provenant de l'extérieur de votre cluster sont bloquées par les règles de pare-feu Google Cloud. Avec IAP, le bon moyen d'exposer cette application à l'Internet public est d'utiliser un équilibreur de charge. N'exposez pas les adresses de nœud à l'aide de règles de pare-feu qui contournent IAP.

Pour acheminer les requêtes vers Bookinfo, vous devez configurer un équilibreur de charge HTTP(S) dans votre projet Google Cloud. Étant donné que l'équilibreur de charge se trouve dans votre projet, il se trouve dans le pare-feu et peut accéder aux nœuds de votre cluster. Une fois que vous avez configuré l'équilibreur de charge avec l'adresse IP statique et le nom de domaine, vous pouvez envoyer des requêtes au nom de domaine. L'équilibreur de charge transfère les requêtes aux nœuds du cluster.

Déployer l'équilibreur de charge

Vous pouvez utiliser une ressource Ingress pour créer un équilibreur de charge HTTP(S) avec des certificats SSL automatiquement configurés. Les certificats SSL gérés par Google sont provisionnés, renouvelés et gérés pour votre domaine.

  1. Créez une ressource ManagedCertificate. Cette ressource spécifie le domaine du certificat SSL. La liste spec.domains ne doit contenir qu'un seul domaine. Les domaines avec des caractères génériques ne sont pas acceptés.

    cat <<EOF | kubectl apply -f -
apiVersion: networking.gke.io/v1beta1
kind: ManagedCertificate
metadata:
  name: example-certificate
  namespace: istio-system
spec:
  domains:
    - ${DOMAIN_NAME}
EOF

  2. Créez l'équilibreur de charge en définissant la ressource Ingress.

    • Définissez l'annotation networking.gke.io/managed-certificates sur le nom du certificat que vous avez créé à l'étape précédente, example-certificate.

    • Définissez l'annotation kubernetes.io/ingress.global-static-ip-name sur le nom de l'adresse IP statique que vous avez réservée, example-static-ip.

    • Définissez serviceName sur istio-ingressgateway, qui est utilisé dans la ressource de passerelle pour l'exemple Bookinfo.

    cat <<EOF | kubectl create -f -
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: example-ingress
  namespace: istio-system
  annotations:
    kubernetes.io/ingress.global-static-ip-name: example-static-ip
    networking.gke.io/managed-certificates: example-certificate
spec:
  backend:
    serviceName: istio-ingressgateway
    servicePort: 80
EOF

  3. Dans la console Google Cloud, accédez à la page Kubernetes Engine > Services et entrée :

    Accéder à la page "Services et entrées"

    Le message "Création d'entrée" doit s'afficher dans la colonne État. Attendez que GKE provisionne entièrement l'entrée avant de continuer. Actualisez la page toutes les deux ou trois minutes pour obtenir l'état le plus récent de l'entrée. Une fois l'entrée provisionnée, l'état "OK" ou le message d'erreur "Tous les services de backend sont DÉFAILLANTS" peut s'afficher. L'une des ressources provisionnées par GKE est une vérification de l'état par défaut. Si le message d'erreur s'affiche, cela signifie que l'entrée est provisionnée et que la vérification de l'état par défaut a été exécutée. Lorsque l'état "OK" ou le message d'erreur s'affiche, passez à la section suivante pour configurer les vérifications de l'état pour l'équilibreur de charge.

Configurer les vérifications de l'état pour l'équilibreur de charge

Pour configurer les vérifications de l'état, vous devez obtenir l'ID de la vérification de l'état par défaut créée par l'entrée, puis mettre à jour celle-ci afin d'utiliser le chemin et le port de la vérification de l'état d'istio-ingress.

  1. Obtenez de nouveaux identifiants utilisateur à utiliser comme identifiants par défaut de l'application.

      gcloud auth application-default login

  2. Récupérez l'ID de la vérification de l'état par défaut créée par l'entrée :

    1. Définissez les variables d'environnement suivantes :

      • Service de backend: crée une liaison entre différents groupes d'instances sur un nœud de service de service donné. 

        BACKEND_SERVICE=$(gcloud compute url-maps list | grep example-ingress | awk '{print $2}' | cut -d'/' -f 2)

      • Vérification d'état: il s'agit de la vérification de l'état d'état par défaut créée automatiquement lors du déploiement de l&#Ingress. 

        HC=$(gcloud compute backend-services describe ${BACKEND_SERVICE} --global | grep healthChecks | cut -d'/' -f 10 | tail -n 1)

      • Port d'entrée de la vérification de l'état: port de vérification de l'état de l'état d'istio-ingress. 

        export HC_INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')

      • Chemin d'entrée de la vérification de l'état: chemin de la vérification de l'état de l'état d'istio-ingress. 

        export HC_INGRESS_PATH=$(kubectl -n istio-system get deployments istio-ingressgateway -o jsonpath='{.spec.template.spec.containers[?(@.name=="istio-proxy")].readinessProbe.httpGet.path}')

      • API de vérification de l'état: API que vous appelez pour configurer la vérification de l'état. 
        export HC_API=https://compute.googleapis.com/compute/v1/projects/${PROJECT_ID}/global/healthChecks/${HC}

    2. Placez la vérification de l'état par défaut dans un fichier JSON en appelant l'API healthChecks :

      curl --request GET  --header "Authorization: Bearer $(gcloud auth application-default print-access-token)" ${HC_API} > health_check.json

  3. Mettez à jour la vérification de l'état pour utiliser le chemin et le port de la vérification de l'état d'istio-ingress :

    1. Mettez à jour le fichier health_check.json comme suit :

      • Définissez httpHealthCheck.port sur la valeur de ${HC_INGRESS_PORT}.
      • Définissez httpHealthCheck.requestPath sur la valeur de ${HC_INGRESS_PATH}.
      • Ajoutez l'attribut suivant et définissez-le sur une chaîne vide : httpHealthCheck.portSpecification=""

      Pour ce faire, le plus simple est d'utiliser jq, qui est préinstallé sur Cloud Shell :

      jq ".httpHealthCheck.port=${HC_INGRESS_PORT} | .httpHealthCheck.requestPath=\"${HC_INGRESS_PATH}\" | .httpHealthCheck.portSpecification=\"\"" health_check.json > updated_health_check.json

      Si vous exécutez cat sur le fichier updated_health_check.json obtenu, celui-ci ressemble à ceci :

      {
"id": "5062913090021441698",
"creationTimestamp": "2019-11-12T10:47:41.934-08:00",
"name": "${HC}",
"description": "Default kubernetes L7 Loadbalancing health check.",
"checkIntervalSec": 60,
"timeoutSec": 60,
"unhealthyThreshold": 10,
"healthyThreshold": 1,
"type": "HTTP",
"httpHealthCheck": {
  "port": 32394,
  "requestPath": "/healthz/ready",
  "proxyHeader": "NONE",
  "portSpecification": ""
},
"selfLink": "https://www.googleapis.com/compute/v1/projects/${PROJECT_ID}/global/healthChecks/${HC}",
"kind": "compute#healthCheck"
}

      Si vous avez modifié le fichier JSON manuellement au lieu d'utiliser la commande jq, enregistrez-le sous le nom updated_health_check.json pour qu'il corresponde au nom de fichier de la commande suivante.

    2. Mettez à jour la vérification de l'état :

      curl --request PATCH --header "Authorization: Bearer $(gcloud auth application-default print-access-token)" --header "Content-Type: application/json" --data @updated_health_check.json ${HC_API}

    La mise à jour de la vérification de l'état par GKE prend plusieurs minutes. Dans la console Google Cloud, actualisez la page Kubernetes Engine > Services et entrées toutes les minutes environ ou jusqu'à ce que l'état de l'entrée indique "OK".

  4. Testez l'équilibreur de charge. Pointez votre navigateur sur :

    http://YOUR_DOMAIN_NAME/productpage

    où YOUR_DOMAIN_NAME est le nom de domaine que vous avez configuré avec l'adresse IP statique externe.

    Le service productpage de l'application Bookinfo devrait s'afficher. Si vous actualisez la page plusieurs fois, vous devriez voir différentes versions d'avis présentées à tour de rôle : étoiles rouges, étoiles noires, sans étoiles.

    Vous devez également tester l'accès https à Bookinfo.

Activer IAP

La procédure suivante explique comment activer IAP.

  1. Vérifiez que vous disposez déjà d'une marque à l'aide de la commande list. Vous ne pouvez disposer que d'une seule marque par projet.

    gcloud iap oauth-brands list

    Voici un exemple de réponse gcloud, si la marque existe :

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true

  2. Si aucune marque n'existe, utilisez la commande create :

    gcloud iap oauth-brands create --application_title=APPLICATION_TITLE --support_email=SUPPORT_EMAIL

    Les champs ci-dessus sont obligatoires lors de l'appel de cette API :

    • supportEmail : l'adresse e-mail d'assistance affichée sur l'écran d'autorisation OAuth. Il peut s'agir de l'adresse e-mail d'un utilisateur ou d'un alias d'adresses e-mail de Google Groupes. Bien que les comptes de service possèdent également une adresse e-mail, celles-ci ne sont pas valides et ne peuvent pas être utilisées lors de la création d'une marque. Toutefois, un compte de service peut être propriétaire d'un groupe Google. Créez un groupe Google ou configurez un groupe existant, puis définissez le compte de service souhaité en tant que propriétaire du groupe.

    • applicationTitle : nom de l'application affiché sur l'écran d'autorisation OAuth.

    La réponse contient les champs suivants :

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true

Créer un client OAuth IAP

  1. Utilisez la commande "create" pour créer un client. Utilisez la marque name de l'étape précédente.

    gcloud iap oauth-clients create projects/PROJECT_NUMBER/brands/BRAND-ID --display_name=NAME

    La réponse contient les champs suivants :

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_NAME]/identityAwareProxyClients/[CLIENT_ID]
secret: [CLIENT_SECRET]
displayName: [NAME]

Activer IAP pour votre service

Pour activer IAP pour votre service, utilisez la commande suivante. Remplacez CLIENT_ID et CLIENT_SECRET par l'ID client OAuth et le code secret du client que vous avez créé précédemment.

gcloud beta iap web enable \
    --oauth2-client-id=CLIENT_ID \
    --oauth2-client-secret=CLIENT_SECRET \
    --resource-type=backend-services \
    --service=${BACKEND_SERVICE}

Configurer la liste d'accès IAP

Ajoutez un utilisateur à la règle d'accès pour IAP :

gcloud beta iap web add-iam-policy-binding \
    --member=user:EMAIL_ADDRESS \
    --role=roles/iap.httpsResourceAccessor \
    --resource-type=backend-services \
    --service=$BACKEND_SERVICE

où EMAIL_ADDRESS est l'adresse e-mail complète de l'utilisateur, telle que alice@example.com.

Activer la compatibilité du jeton RCToken sur le maillage de services

Par défaut, IAP génère un jeton Web JSON (JWT) limité au client OAuth. Pour Anthos Service Mesh, vous pouvez configurer IAP pour générer un jeton RequestContextToken (RCToken), qui est un jeton JWT, mais avec une audience configurable. RCToken vous permet de configurer l'audience du jeton JWT vers une chaîne arbitraire, qui peut être utilisée dans les stratégies Anthos Service Mesh pour une autorisation précise.

Pour configurer le jeton RCToken, procédez comme suit :

  1. Créez une variable d'environnement pour votre numéro de projet. Il s'agit du numéro généré automatiquement et attribué à votre projet lors de sa création. (Cette valeur est différente de l'ID de projet).

    export PROJECT_NUMBER=YOUR_PROJECT_NUMBER

  2. Créez une variable d'environnement pour l'audience du jeton RCToken. Vous pouvez choisir n'importe quelle chaîne.

    export RCTOKEN_AUD="your-rctoken-aud"

  3. Récupérez les paramètres IAP existants

    gcloud beta iap settings get --format json \
--project=${PROJECT_NUMBER} --resource-type=compute \
--service=${BACKEND_SERVICE} > iapSettings.json

  4. Mettez à jour IapSettings avec l'audience du jeton RCToken.

    cat iapSettings.json | jq --arg RCTOKEN_AUD_STR $RCTOKEN_AUD \
'. + {applicationSettings: {csmSettings: {rctokenAud: $RCTOKEN_AUD_STR}}}' \
> updatedIapSettings.json

    gcloud beta iap settings set updatedIapSettings.json --format json \
--project=${PROJECT_NUMBER} --resource-type=compute --service=${BACKEND_SERVICE}

  5. Activez l'authentification RCToken sur la passerelle d'entrée Istio.

    cat <<EOF | kubectl apply -f -
apiVersion: "authentication.istio.io/v1alpha1"
kind: "Policy"
metadata:
  name: "ingressgateway"
  namespace: istio-system
spec:
  targets:
  - name: "istio-ingressgateway"
  origins:
  - jwt:
      issuer: "https://cloud.google.com/iap"
      jwksUri: "https://www.gstatic.com/iap/verify/public_key-jwk"
      audiences:
      - "$RCTOKEN_AUD"
      jwt_headers:
      - "ingress-authorization"
      trigger_rules:
      - excluded_paths:
        - exact: /healthz/ready
  principalBinding: USE_ORIGIN
EOF

  6. Assurez-vous que les requêtes adressées à Bookinfo productpage aboutissent :

    http://DOMAIN_NAME/productpage

Pour tester la stratégie, procédez comme suit :

  1. Créez un objet de requête IapSettings, mais définissez la valeur rctokenAud sur une chaîne différente :

    echo $(cat <<EOF
{
   "name": "projects/${PROJECT_NUMBER}/iap_web/compute/services/${BACKEND_SERVICE}",
   "applicationSettings": {
     "csmSettings": {
       "rctokenAud": "some-other-arbitrary-string"
     }
   }
 }
EOF
) > request.txt

  2. Appelez l'API IapSettings pour définir l'audience du jeton RCToken.

    curl --request PATCH --header "Authorization: Bearer $(gcloud beta auth application-default print-access-token)" ${IAP_SETTINGS_API}

  3. Envoyez une requête au service productpage Bookinfo. Celle-ci devrait échouer :

    http://DOMAIN_NAME/productpage

Nettoyer

Une fois ce tutoriel terminé, supprimez les ressources suivantes pour éviter que des frais supplémentaires ne soient facturés sur votre compte :

  1. Supprimez le certificat géré :

    kubectl delete managedcertificates example-certificate

  2. Supprimez la ressource Ingress, qui libère les ressources d'équilibrage de charge: 

    kubectl -n istio-system delete ingress example-ingress

  3. Supprimez l'adresse IP statique : 

    gcloud compute addresses delete example-static-ip --global

    Si vous procédez ainsi, veillez à supprimer l'adresse IP de votre service d'enregistrement de noms de domaine.

  4. Supprimez le cluster, qui supprime les ressources qui le composent, telles que les instances de calcul, les disques et les ressources réseau: 

    gcloud container clusters delete ${CLUSTER_NAME}