A la découverte de Istio

Publié le par piermick

Istio est une plateforme open source qui permet de connecter, sécuriser, contrôler et observer les services dans un réseau de type mesh.

Un service mesh est une infrastructure qui facilite la communication entre les microservices d’une application distribuée.

  • Istio offre des fonctionnalités telles que la découverte de services, le routage du trafic, la gestion des erreurs, la tolérance aux pannes, la sécurité, la télémétrie et l’observabilité.
  • Istio est conçu pour être indépendant de la plateforme sous-jacente, ce qui signifie qu’il peut fonctionner sur différents environnements comme Kubernetes, Nomad, VMs ou bare metal.

En résumé :

  • 🌐 Les architectures micro-services améliorent la capacité des équipes logicielles modernes.
  • 🤝 Les Services Mesh sont nés pour surmonter les défis de la multiplication des micro-services.
  • 🛠️ Les fonctionnalités fournies par les Services Mesh incluent la découverte de service, le LoadBalancing, l’authentification, etc.
  • 🤔 Pourquoi choisir Istio, le service Mesh open source ?
  • 🔄 Istio connecte, surveille et sécurise des micro-services déployés sur site, dans le cloud ou via des plates-formes d’orchestration comme Kubernetes.
  • 🚀 Istio offre une alternative aux déploiements de micro-services et devient de plus en plus lié à Kubernetes.
  • 🌐 Qu’est-ce qu’un Service Mesh ?
  • 📦 Les avantages des architectures micro-services incluent l’isolation des fonctionnalités, la livraison indépendante, la facilité de maintenance, de test, l’efficacité, et l’agilité.
  • 🕸️ Un Service Mesh est une couche d’infrastructure permettant la communication entre les API et la configuration des actions critiques.
  • 🔄 Utiliser un service Mesh offre une flexibilité en automatisant des éléments tels que le design for failure, l’authentification et le monitoring.
  • 🧩 Cela permet de déplacer les micro-services sans toucher au code, simplifiant la gestion.
  • ⚙️ Comment Istio fonctionne ?
  • 🌐 L’architecture d’un Service Mesh comprend le Data Plane (proxy gérant les communications) et le Control Plane (supervisant les stratégies et configurations).
  • 🛠️ Envoy est le proxy utilisé dans le Data Plane d’Istio, assurant observabilité et traçabilité.
  • 🧭 Le Control Plane, composé de Pilot, Mixer, et Citadel, orchestre les stratégies, configurations, et la sécurité.
  • 🧭 Les composants du Service Mesh Istio :
  • 🚦 Pilot gère le trafic, le routage, le rate limiting et la résilience.
  • 🔄 Mixer rassemble les données du proxy Envoy pour appliquer les politiques réseau.
  • 🔒 Citadel assure la sécurité avec des règles d’authentification et de gestion d’informations d’identification.
  • ❓ Devons-nous adopter Istio ?
  • 📈 Istio est en croissance, adopté par de nombreuses entreprises et certains fournisseurs de cloud.
  • 🛠️ Tester Istio dans une architecture micro-service permet de comprendre son impact avant potentiellement de l’adopter.

Schéma de Istio

Ci-dessous le schéma de fonctionnement de Istio

Déploiement de Istio

Prérequis

  • Helm : choco install kubernetes-helm
  • Kubectl : choco install kubernetes-cli
  • az cli : choco install azure-cli

Le script PowerShell suivant vous permet de déployer votre cluster AKS

$resourcegroup="rgakspmc"
$clusterAks="akspmc"
az login
az group create --name $resourcegroup --location westeurope
az aks create --resource-group $resourcegroup --name $clusterAks --node-count 3 --enable-addons monitoring --generate-ssh-keys
az aks get-credentials -n $akscluster -g $resourcegroup

Votre cluster est maintenant disponible

Authentifiez vous sur le cluster en exécutant les commandes suivantes

Télécharger ensuite istioctl pour administrer Istio sur votre poste

$ISTIO_VERSION="1.7.3"
[Net.ServicePointManager]::SecurityProtocol = "tls12"
$ProgressPreference = 'SilentlyContinue'; Invoke-WebRequest -URI "https://github.com/istio/istio/releases/download/$ISTIO_VERSION/istioctl-$ISTIO_VERSION-win.zip" -OutFile "istioctl-$ISTIO_VERSION.zip"
Expand-Archive -Path "istioctl-$ISTIO_VERSION.zip" -DestinationPath . 
New-Item -ItemType Directory -Force -Path "C:\Istio"
Move-Item -Path .\istioctl.exe -Destination "C:\Istio\"
$USER_PATH = [environment]::GetEnvironmentVariable("PATH", "User") + ";C:\Istio\"
[environment]::SetEnvironmentVariable("PATH", $USER_PATH, "User")
$env:PATH += ";C:\Istio\"

Puis installer le via la commande suivante

istioctl operator init

Créer ensuite le namespace de istio dans votre cluster Kubernetes afin de le déployer dans celui-ci

kubectl create ns istio-system

Installer ensuite les customs ressources Istio sans quoi vous aurez l’erreur suivante :

Le yaml des customs ressources est disponible ici :

https://github.com/pmchancrin/customresourcedefinitions/blob/main/customresourcedefinitions.gen.yaml

Créer le fichier puis appliquer les modifications

kubectl apply -f .\customresourcedefinitions.gen.yaml

Déployer maintenant l’opérateur istio dans votre cluster, pour cela crée run fichier istio.yaml comme ci-dessous :

apiVersion: install.istio.io/v1beta1
kind: IstioOperator
metadata:
  namespace: istio-system
  name: istio-control-plane
spec:
  # Use the default profile as the base
  # More details at: https://istio.io/docs/setup/additional-setup/config-profiles/
  profile: default
  # Enable the addons that we will want to use
  addonComponents:
    grafana:
      enabled: true
    prometheus:
      enabled: true
    tracing:
      enabled: true
    kiali:
      enabled: true
  values:
    global:
      # Ensure that the Istio pods are only scheduled to run on Linux nodes
      defaultNodeSelector:
        beta.kubernetes.io/os: linux
    kiali:
      dashboard:
        auth:
          strategy: anonymous

Puis déployez le en exécutant la commande ci-dessous :

kubectl apply -f istio.yaml

istio est maintenant déployé sur votre cluster AKS

Déployer une application

Source des fichiers yaml : https://github.com/pmchancrin/customresourcedefinitions

Déployer la Gateway pour rendre votre accessible depuis l’extérieur du cluster

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  namespace: pmcapplication
  name: pmc-gateway
spec:
  selector:
    istio: ingressgateway # use istio default controller
  servers:
  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - "*"

Déployer ensuite votre application

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: pmcapplication
  name: front-v1
  labels:
    app: front
    version: v1
spec:
  selector:
    matchLabels:
      app: front
      version: v1
  replicas: 1
  template:
    metadata:
      labels:
        app: front
        version: v1
    spec:
      serviceAccountName: front
      containers:
      - name: front
        image: moustafarai/front:1.0.0
        stdin: true
        tty: true
        resources:
          requests:
            cpu: "200m"

            memory : "500Mi"
          limits:
            cpu: "0.4"
            memory : "701Mi"
        ports:
        - containerPort: 3000
          protocol: TCP
---
apiVersion: v1
kind: ServiceAccount
metadata:
  namespace: pmcapplication
  name: front
  labels:
    account: front
---
apiVersion: v1
kind: Service
metadata:
  namespace: pmcapplication
  name: front
  labels:
    app: front
    service: front
spec:
  ports:
  - name: http
    port: 3000
  selector:
    app: front

Nous allons ensuite mettre en place les redirections (subsets) vers la V1 de votre application. Ces informations seront ensuite visible dans le portail Kiali

apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  namespace: pmcapplication
  name: front-destination
spec:
  host: front
  subsets:
  - name: v1
    labels:
      version: v1
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  namespace: pmcapplication
  name: webapia-destination
spec:
  host: webapia
  subsets:
  - name: v1
    labels:
      version: v1
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  namespace: pmcapplication
  name: webapib-destination
spec:
  host: webapib
  subsets:
  - name: v1
    labels:
      version: v1
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  namespace: pmcapplication
  name: webapic-destination
spec:
  host: webapic
  subsets:
  - name: v1
    labels:
      version: v1
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  namespace: pmcapplication
  name: webapid-destination
spec:
  host: webapid
  subsets:
  - name: v1
    labels:
      version: v1

Visualiser les services Mesh avec Istio

  • Pour cela, je vous invite a utiliser Lens disponible ici : Lens : Kubernetes IDE (lien vers Github)

Depuis L’outil LENS installé précédemment il est possible d’accéder a Kiali en cliquant sur Network, Service puis sélectionner Kiali.

Cliquer ensuite sur le lien comme ci-dessous :

C’est un outil qui vous permet de gérer, visualiser, valider et dépanner votre service mesh Istio.

Source : https://kiali.io/documentation/

Il vous aide à comprendre la structure de votre service mesh en inférant la topologie, et vous fournit également des informations sur la santé de votre service mesh.

  • Kiali offre une topologie du trafic détaillée, des indicateurs de santé, des tableaux de bord puissants, et vous permet d’accéder aux détails des composants .
  • Kiali s’intègre également avec d’autres outils comme Jaeger, qui est un outil de traçage qui permet de déterminer le chemin d’un appel réseau en s’appuyant sur les en-têtes HTTP Opentrace.

Déployons ensuite la V2 de notre application

Nous allons ensuite mettre en place les redirections (subsets) vers la V1 et la V2 de votre application.

Les « subsets » se base sur les labels pour la redirection du trafic comme le montre l’exemple ci-dessous

labels:
    app: webapia
    version: v1

Ces informations seront ensuite visible dans le portail Kiali.

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: pmcapplication
  name: webapia-v2
  labels:
    app: webapia
    version: v2
spec:
  selector:
    matchLabels:
      version: v2
      app: webapia
  replicas: 1
  template:
    metadata:
      labels:
        version: v2
        app: webapia
    spec:
      serviceAccountName: webapia
      containers:
      - name: webapia
        image: moustafarai/webapia:2.0.0
        resources:
          requests:
            cpu: "200m"
            memory : "200Mi"
          limits:
            cpu: "0.4"
            memory : "201Mi"
        ports:
        - containerPort: 80
          protocol: TCP

Déployons ensuite les règles de destinations 

apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  namespace: pmcapplication
  name: front-destination
spec:
  host: front
  subsets:
  - name: v1
    labels:
      version: v1
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  namespace: pmcapplication
  name: webapia-destination
spec:
  host: webapia
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  namespace: pmcapplication
  name: webapib-destination
spec:
  host: webapib
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  namespace: pmcapplication
  name: webapic-destination
spec:
  host: webapic
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: webapid-destination
spec:
  host: webapid
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2

Ensuite, redirigeons 50% du trafic sur notre V1 et 50% sur notre V2, nous pouvons visualiser cela sur Kiali

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  namespace: pmcapplication
  name: front
spec:
  hosts:
  - "*"
  gateways:
  - pmc-gateway
  http:
  - match:
    - uri:
        prefix: "/demo"
    - uri:
        prefix: /static
    route:
    - destination:
        subset: v1
        host: front        
        port:
          number: 3000  
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  namespace: pmcapplication
  name: webapia
spec:
  hosts:
  - "*"
  gateways:
  - pmc-gateway
  http:
  - match:
    - uri:
        prefix: "/ServiceA"
    route:
    - destination:
        subset: v1
        host: webapia
        port:
          number: 80
      weight: 50
    - destination:
        subset: v2
        host: webapia
        port:
          number: 80
      weight: 50
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  namespace: pmcapplication
  name: webapib
spec:
  hosts:
  - "*"
  gateways:
  - pmc-gateway
  http:
  - match:
    - uri:
        prefix: "/ServiceB"
    route:
    - destination:
        subset: v1
        host: webapib
        port:
          number: 80
      weight: 50
    - destination:
        subset: v2
        host: webapib
        port:
          number: 80
      weight: 50
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  namespace: pmcapplication
  name: webapic
spec:
  hosts:
  - "*"
  gateways:
  - pmc-gateway
  http:
  - match:
    - uri:
        prefix: "/ServiceC"
    route:
    - destination:
        subset: v1
        host: webapic
        port:
          number: 80
      weight: 50
    - destination:
        subset: v2
        host: webapic
        port:
          number: 80
      weight: 50
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  namespace: pmcapplication
  name: webapid
spec:
  hosts:
  - "*"
  gateways:
  - demo-gateway
  http:
  - match:
    - uri:
        prefix: "/ServiceD"
    route:
    - destination:
        subset: v1
        host: webapid
        port:
          number: 80
      weight: 50
    - destination:
        subset: v2
        host: webapid
        port:
          number: 80
      weight: 50

Cela pour permettra par exemple de suivre le trafic, notamment si vous redirigé 50% de votre trafic sur la V1 de votre application et 50% sur la V2 en se basant sur les labels.

Source : https://www.youtube.com/watch?v=6zDrLvpfCK4

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur la façon dont les données de vos commentaires sont traitées.