Sécuriser les services Kubernetes avec Istio

Ce tutoriel est destiné aux utilisateurs et aux administrateurs Kubernetes qui souhaitent utiliser le maillage de services Istio pour déployer de manière sécurisée des services Kubernetes et activer la communication TLS mutuelle (mTLS).

Istio et Cloud Service Mesh

Istio n'est pas un produit Google compatible. Nous vous recommandons d'exécuter plutôt Cloud Service Mesh géré. Pour en savoir plus, consultez Provisionner Cloud Service Mesh sur un cluster GKE Autopilot.

Cloud Service Mesh offre les avantages suivants :

  • Vous pouvez provisionner Cloud Service Mesh géré à l'aide de l'API Fleet sans outils côté client tels que istioctl.
  • Cloud Service Mesh injecte automatiquement des proxys side-car dans les charges de travail sans accorder de privilèges élevés à vos conteneurs.
  • Vous pouvez afficher des tableaux de bord enrichis pour votre maillage et vos services sans aucune configuration supplémentaire, puis utiliser ces métriques pour configurer des objectifs de niveau de service (SLO) et des alertes pour surveiller l'état de vos applications.
  • Le plan de contrôle géré Cloud Service Mesh est mis à niveau automatiquement pour vous assurer que vous disposez des derniers correctifs et fonctionnalités de sécurité.
  • Le plan de données géré de Cloud Service Mesh met automatiquement à niveau les proxys side-car dans vos charges de travail. Vous n'avez ainsi pas besoin de redémarrer les services vous-même lorsque des mises à niveau de proxy et des correctifs de sécurité sont disponibles.
  • Cloud Service Mesh est un produit compatible et peut être configuré à l'aide des API Istio Open Source standards. Pour en savoir plus, consultez la section Fonctionnalités compatibles.

Objectifs

Ce tutoriel comprend les étapes suivantes :

  • Créer un cluster GKE Autopilot
  • Installer Istio à l'aide de l'outil de ligne de commande istioctl.
  • Déployer un exemple d'application pour tester l'authentification TLS mutuelle (mTLS).
  • Configurer Istio afin qu'il utilise l'authentification mTLS pour la communication de service à service à l'aide d'une ressource personnalisée PeerAuthentication.
  • Vérifier l'authentification mTLS à l'aide du tableau de bord Kiali.

Coûts

Dans ce document, vous utilisez les composants facturables de Google Cloudsuivants :

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, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Les logiciels dont vous avez besoin pour ce tutoriel sont préinstallés sur Cloud Shell, y compris kubectl, gcloud CLI, Terraform. Si vous n'utilisez pas Cloud Shell, vous devez installer gcloud CLI.

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. Install the Google Cloud CLI.

  3. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

  4. Pour initialiser la gcloud CLI, exécutez la commande suivante : 

    gcloud init

  5. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the GKE API: 

    gcloud services enable container.googleapis.com

  8. Install the Google Cloud CLI.

  9. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

  10. Pour initialiser la gcloud CLI, exécutez la commande suivante : 

    gcloud init

  11. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  12. Verify that billing is enabled for your Google Cloud project.

  13. Enable the GKE API: 

    gcloud services enable container.googleapis.com

  14. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/container.clusterAdmin 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE

    Replace the following:

    • PROJECT_ID: your project ID.
    • USER_IDENTIFIER: the identifier for your user account—for example, myemail@example.com.
    • ROLE: the IAM role that you grant to your user account.

    15. Préparer l'environnement

    Pour configurer votre environnement, procédez comme suit :

    1. Définissez les variables d'environnement :

      export PROJECT_ID=PROJECT_ID
gcloud config set project $PROJECT_ID
gcloud config set compute/region us-central1

      Remplacez PROJECT_ID par votre Google Cloud ID de projet.

    2. Clonez le dépôt GitHub.

      git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

    3. Accédez au répertoire de travail :

      cd kubernetes-engine-samples/service-mesh/istio-tutorial

    Créer un cluster GKE

    Activez les fonctionnalités Linux requises par Istio : NET_RAW et NET_ADMIN. GKE Autopilot n'autorise pas NET_ADMIN par défaut, mais vous pouvez activer NET_ADMIN à l'aide de la commande --workload-policies=allow-net-admin dans GKE 1.27 et versions ultérieures :

    gcloud container clusters create-auto istio-cluster \
    --location="us-central1" \
    --workload-policies="allow-net-admin"

    Pour en savoir plus sur la sécurité de GKE Autopilot, consultez la page Configurations de sécurité intégrées.

    Installer Istio

    Vous pouvez installer Istio sur un cluster GKE à l'aide de Istioctl.

    Dans ce tutoriel, vous installez Istio avec le profil de configuration par défaut recommandé pour les déploiements de production.

    1. Installez Istio :

      • Pour installer la dernière version d'Istio :

        curl -L https://istio.io/downloadIstio | sh -

      • Pour installer une version spécifique d'Istio :

        export ISTIO_VERSION=VERSION_NUMBER
curl -L https://istio.io/downloadIstio | TARGET_ARCH=$(uname -m) sh -

        Remplacez VERSION_NUMBER par la version d'Istio que vous souhaitez installer. Pour en savoir plus sur les versions d'Istio, consultez les annonces de version.

    2. Ajoutez l'outil de ligne de commande istioctl au PATH :

      cd istio-*
export PATH=$PWD/bin:$PATH

    3. Installez Istio sur le cluster :

      istioctl install --set profile="default" -y

      Cette étape peut prendre plusieurs minutes.

    4. Attendez que les pods Istio soient prêts :

      watch kubectl get pods -n istio-system

      Le résultat ressemble à ce qui suit :

      NAME                                    READY   STATUS        RESTARTS   AGE
istio-ingressgateway-5c47bff876-wjm96   1/1     Running       0          2m54s
istiod-5fc7cb65cd-k8cp4                 1/1     Running       0          2m57s

      Lorsque les pods Istio affichent l'état Running, revenez à la ligne de commande en appuyant sur Ctrl+C.

    Déployer l'exemple d'application

    Dans cette section, vous allez utiliser l'exemple d'application Bank of Anthos pour créer un maillage de services avec authentification mTLS.

    1. Ajoutez un libellé d'espace de noms qui indique à Istio d'activer l'injection automatique des proxys side-car Envoy :

      kubectl label namespace default istio-injection=enabled

    2. Déployez l'exemple d'application :

      cd ..
git clone https://github.com/GoogleCloudPlatform/bank-of-anthos.git
kubectl apply -f bank-of-anthos/extras/jwt/jwt-secret.yaml
kubectl apply -f bank-of-anthos/kubernetes-manifests/

    3. Attendez que l'application soit prête :

      watch kubectl get pods

      Le résultat ressemble à ce qui suit :

      NAME                                 READY   STATUS    RESTARTS   AGE
accounts-db-0                        2/2     Running   0          2m16s
balancereader-5c695f78f5-x4wlz       2/2     Running   0          3m8s
contacts-557fc79c5-5d7fg             2/2     Running   0          3m7s
frontend-7dd589c5d7-b4cgq            2/2     Running   0          3m7s
ledger-db-0                          2/2     Running   0          3m6s
ledgerwriter-6497f5cf9b-25c6x        2/2     Running   0          3m5s
loadgenerator-57f6896fd6-lx5df       2/2     Running   0          3m5s
transactionhistory-6c498965f-tl2sk   2/2     Running   0          3m4s
userservice-95f44b65b-mlk2p          2/2     Running   0          3m4s

      Une fois les pods à l'état Running, revenez à la ligne de commande en appuyant sur Ctrl+C.

    4. Examinez le fichier manifeste suivant :

      # Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: frontend-gateway
spec:
  selector:
    istio: ingressgateway # use Istio default gateway implementation
  servers:
  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - "*"
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: frontend-ingress
spec:
  hosts:
  - "*"
  gateways:
  - frontend-gateway
  http:
  - route:
    - destination:
        host: frontend
        port:
          number: 80

      Ce fichier manifeste décrit les ressources Istio Gateway et VirtualService qui exposent l'application et utilisent Istio comme contrôleur d&#Ingress.

    5. Appliquez le fichier manifeste à votre cluster :

      kubectl apply -f bank-of-anthos/extras/istio/frontend-ingress.yaml

    Configurer mTLS

    L'authentification TLS mutuelle (mTLS) est activée par défaut dans Istio. Cela signifie qu'Istio surveille les charges de travail serveur qui ont été migrées vers les proxys Istio et configure automatiquement les proxys clients pour établir des connexions mTLS avec ces charges de travail. Istio configure également les proxys clients pour qu'ils n'utilisent pas l'authentification mTLS lors de la connexion à des charges de travail sans proxy side-car.

    Istio peut configurer mTLS pour qu'il fonctionne selon trois modes :

    • PERMISSIVE : les charges de travail acceptent à la fois le trafic mTLS et le trafic en texte brut.
    • STRICT : les charges de travail n'acceptent que le trafic mTLS.
    • DISABLE : mTLS est désactivé. Utilisez ce mode si vous souhaitez utiliser votre propre solution de sécurité.

    Vous pouvez appliquer la configuration mTLS de manière globale, par espace de noms ou par charge de travail. Dans ce tutoriel, vous appliquez la configuration par espace de noms à l'aide du mode mTLS STRICT.

    1. Examinez le fichier manifeste suivant :

      apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
spec:
  mtls:
      mode: STRICT

      Ce fichier manifeste décrit une ressource personnalisée Istio d'authentification de pairs.

    2. Appliquez le fichier manifeste à votre cluster :

      kubectl apply -f peer-authentication.yaml

    Pour en savoir plus sur mTLS dans Istio, consultez la page Authentification TLS mutuelle.

    Vérifier que mTLS est activé

    Kiali est un tableau de bord d'observabilité Web pour le maillage de services Istio qui fournit une vue graphique de votre environnement de microservices, ce qui vous permet de surveiller et de dépanner vos applications. Vous pouvez utiliser Kiali pour vérifier que l'authentification mTLS est activée et fonctionne correctement dans le maillage de services Istio. Kiali nécessite Prometheus comme source de données de télémétrie. Ce tutoriel utilise Google Cloud Managed Service pour Prometheus.

    Installer une interface de requête

    1. Créez un compte de service IAM avec le rôle roles/monitoring.viewer pour autoriser l'interface de requête à accéder aux métriques :

      gcloud iam service-accounts create monitoring \
    --display-name="Service account for query interface"
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:monitoring@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/monitoring.viewer
gcloud iam service-accounts add-iam-policy-binding \
  monitoring@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[monitoring/default]"

    2. Créez un espace de noms Kubernetes :

      kubectl create namespace monitoring

    3. Annotez le compte de service Kubernetes par défaut dans l'espace de noms pour configurer la fédération d'identité de charge de travail pour GKE :

      kubectl annotate serviceaccount -n monitoring default \
    iam.gke.io/gcp-service-account=monitoring@PROJECT_ID.iam.gserviceaccount.com --overwrite

    4. Déployez la charge de travail d'interface de requête :

      kubectl -n monitoring apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.7.1/examples/frontend.yaml

    5. Examinez le fichier manifeste suivant :

      apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: istiod
  namespace: istio-system
spec:
  selector:
    matchLabels:
      app: istiod
  endpoints:
  - port: 15014
    path: /metrics
    timeout: 30s
    interval: 60s

      Ce fichier manifeste décrit une ressource PodMonitoring qui collecte les métriques d'Istio et de proxy Envoy.

    6. Appliquez le fichier manifeste à votre cluster :

      kubectl apply -f pod-monitorings.yaml

    7. Obtenez un lien vers l'exemple d'application :

      INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo "http://$INGRESS_HOST"

    8. Ouvrez le lien pour afficher l'exemple d'application. Connectez-vous avec le nom d'utilisateur et le mot de passe par défaut pour générer du trafic entre les microservices.

    Installer Kiali

    Nous vous recommandons d'installer Kiali à l'aide de l'opérateur Kiali.

    1. Installez l'opérateur Kiali :

      helm repo add kiali https://kiali.org/helm-charts
helm repo update
helm install \
    --namespace kiali-operator \
    --create-namespace \
    kiali-operator \
    kiali/kiali-operator

    2. Examinez le fichier manifeste suivant :

      apiVersion: kiali.io/v1alpha1
kind: Kiali
metadata:
  name: kiali
  namespace: istio-system
spec:
  deployment:
    namespace: istio-system
  auth:
    strategy: anonymous
  external_services:
    custom_dashboards:
      prometheus:
        url: "http://frontend.monitoring:9090/"
        auth:
          type: none
    prometheus:
      url: "http://frontend.monitoring:9090/"
      auth:
        type: none
    tracing:
      enabled: false
    grafana:
      enabled: false

      Ce fichier manifeste décrit une ressource personnalisée d'opérateur qui définit le serveur Kiali.

    3. Appliquez le fichier manifeste à votre cluster :

      kubectl apply -f kiali.yaml

    4. Attendez que le serveur Kiali soit prêt :

      watch kubectl get pods -n istio-system

      Le résultat ressemble à ce qui suit :

      NAME                                    READY   STATUS    RESTARTS   AGE
istio-ingressgateway-6845466857-92zp8   1/1     Running   0          9m11s
istiod-6b47d84cf-4cqlt                  1/1     Running   0          12m

      Une fois les pods à l'état Running, revenez à la ligne de commande en appuyant sur Ctrl+C.

    5. Configurez un transfert de port sur le service du serveur Kiali pour accéder au tableau de bord :

      kubectl -n istio-system port-forward svc/kiali 8080:20001

    6. Ouvrez l'aperçu Web. Dans Kiali, accédez à la section Graphique et sélectionnez l'option Sécurité dans la liste déroulante Affichage. Cette vue affiche l'état de sécurité de chaque nœud dans le graphique. Les nœuds portant le badge mTLS activé indiquent que mTLS est activé pour ce service, tandis que les nœuds sans badge indiquent que mTLS n'est pas activé.

    Effectuer un nettoyage

    Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

    Supprimer le projet

      Delete a Google Cloud project:

      gcloud projects delete PROJECT_ID

    Supprimer les ressources individuelles

    Si vous avez utilisé un projet existant et que vous ne souhaitez pas le supprimer, supprimez les ressources individuelles.

    1. Supprimez Kiali :

      kubectl -n istio-system delete kiali kiali
helm uninstall --namespace kiali-operator kiali-operator

    2. Supprimez les ressources de surveillance :

      kubectl -n monitoring delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.7.1/examples/frontend.yaml

    3. Supprimez l'exemple d'application :

      kubectl delete -f bank-of-anthos/extras/istio/frontend-ingress.yaml
kubectl delete -f bank-of-anthos/kubernetes-manifests

    4. Désinstallez Istio :

      istioctl uninstall --purge -y

    5. Supprimez le cluster GKE :

      gcloud container clusters delete --location us-central1 istio-cluster --quiet

    Étapes suivantes

    • Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Cloud Architecture Center.