Sécuriser les services Kubernetes avec Istio

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 l'ID de votre projet Google Cloud.

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 :

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

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

   cd istio-${ISTIO_VERSION}
   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'entrée.

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 avec le badge mTLS activé indiquent que l'authentification mTLS est activée pour ce service, tandis que les nœuds sans badge indiquent que mTLS n'est pas activé.