Service Mesh 101

Istio

2023, Feb 10

J’espère que cette suite de billets sera utile pour votre voyage au pays des services mesh.

Un Service Mesh c’est quoi ?
Istio

Istio est une solution open source de service mesh qui s’intègre de manière transparente à l’existant.
Il n’y a pas besoin de modifier son code pour profiter des apports des services mesh.

Nous allons voir pas à pas comment installer Istio et les fonctionnalités qu’il peut offrir.

Pré-requis

Un cluster Kubernetes en version 1.22, 1.23, 1.24 ou 1.25
L’accès au service de type Loadbalancer (LB cloud, metallb, etc..)
Linux ou MacOS pour le cli d’istio

Installation

Dans ce billet, je vais utiliser MacOS and un cluster kubernetes en version 1.24 provisionné par kubeadm.

Pour commencer, nous allons télécharger istioctl

> curl -L https://istio.io/downloadIstio | sh -
> cd istio-X-YY-Z
> export PATH=$PWD/bin:$PATH

Nous allons ensuite exécuter les precheck pour s’assurer qu`Istio peux être installé (ou updater) sur notre environnement.

> istioctl experimental precheck

No issues found when checking the cluster. Istio is safe to install or upgrade!
To get started, check out https://istio.io/latest/docs/setup/getting-started/

Nous pouvons maintenant installer Istio en utilisant le profile demo.
Ce profil contient toutes les valeurs de configuration pour un environnement de test.
Il existe d’autres profile existant comme celui de production par exemple.

> istioctl install --set profile=demo -y

✔ Istio core installed
✔ Istiod installed
✔ Ingress gateways installed
✔ Egress gateways installed
✔ Installation complete

Making this installation the default for injection and validation.

Istio est installé dans le namespace istio-system, nous pouvons vérifier que tout tourne correctement.

> kubectl get po -n istio-system

NAME READY STATUS RESTARTS AGE
istio-egressgateway-688d4797cd-4gjwr 1/1 Running 0 3m32s
istio-ingressgateway-6bd9cfd8-xz8b9 1/1 Running 0 3m32s
istiod-68fdb87f7-nnpp2 1/1 Running 0 3m42s

Il nous faut également vérifier qu’Istio ai bien obtenu un adresse IP external. J’ai remplacé la mienne par X.X.X.X.

> kubectl get svc -n istio-system
NAME                   TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)                                                                      AGE
istio-egressgateway    ClusterIP      10.109.214.225   <none>        80/TCP,443/TCP                                                               4m31s
istio-ingressgateway   LoadBalancer   10.98.55.56      X.X.X.X       15021:30712/TCP,80:32215/TCP,443:31094/TCP,31400:31664/TCP,15443:32433/TCP   4m31s
istiod                 ClusterIP      10.111.57.100    <none>        15010/TCP,15012/TCP,443/TCP,15014/TCP                                        4m41s

Configuration

Nous allons maintenant préparer et configurer notre namespace.
Pour cela, nous allons créer un namespace nommé demo.

> kubectl create ns demo

Puis nous allons y ajouter un label afin de dire à Istio qu’il doit automatiquement injecter le sidecar proxy (Envoy) à nos applications déployer dans ce namespace.

> kubectl label namespace demo istio-injection=enabled

Nous pouvons vérifier que le label est bien ajouté comme ceci :

> kubectl get ns demo --show-labels

Application de démo

Il est temps de déployer l’application de démonstration bookinfo qui nous est fourni par Istio.
Assurons-nous d’être dans notre répertoire d’istio et appliquons le manifeste de l’application.

> kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml -n demo

service/details created
serviceaccount/bookinfo-details created
deployment.apps/details-v1 created
service/ratings created
serviceaccount/bookinfo-ratings created
deployment.apps/ratings-v1 created
service/reviews created
serviceaccount/bookinfo-reviews created
deployment.apps/reviews-v1 created
deployment.apps/reviews-v2 created
deployment.apps/reviews-v3 created
service/productpage created
serviceaccount/bookinfo-productpage created
deployment.apps/productpage-v1 created

Nous pouvons vérifier que les pods sont bien en train de tourner.

> kubectl get po -n demo

NAME                              READY   STATUS    RESTARTS   AGE
details-v1-7d4d9d5fcb-bwrxx       2/2     Running   0          89s
productpage-v1-66756cddfd-2ffqh   2/2     Running   0          88s
ratings-v1-85cc46b6d4-t4r6m       2/2     Running   0          89s
reviews-v1-777df99c6d-f5blv       2/2     Running   0          89s
reviews-v2-cdd8fb88b-d4dxz        2/2     Running   0          89s
reviews-v3-58b6479b-shbvn         2/2     Running   0          89s

Afin de vérifier que tout fonctionne correctement, nous allons déployer un pod contenant curl et nous accéder à notre application bookinfo depuis ce pod.
Voici le manifeste à appliquer.

apiVersion: v1
kind: Pod
metadata:
  name: curl
  labels:
    app: curl
spec:
  containers:
  - command:
    - /bin/sh
    - -c
    - --
    args:
    - while true; do sleep 30; done;
    image: curlimages/curl
    name: curl

Nous pouvons maintenant exécuter notre requête curl sur l’endpoint de la page produit productpage:9080.

> kubectl exec curl -- curl -Ss productpage:9080

<!DOCTYPE html>
<html>
  <head>
    <title>Simple Bookstore App</title>
<meta charset="utf-8"
...
...
...

Exposer notre application à l’extérieur du cluster

Afin de pouvoir accéder à notre application depuis l’extérieur, nous avons besoin d’une Ingress Gateway.
Les Ingress Gateway d’Istio permettent de manager le trafic entrant et sortant de notre service mesh.
Il suffit définir le(s) host(s) et le(s) port(s) à utiliser pour notre service.
Voici la Gateway et le VirtualService fournit avec l’application de démonstration.

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: bookinfo-gateway
spec:
  selector:
    istio: ingressgateway # use istio default controller
  servers:
  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - "*"
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: bookinfo
spec:
  hosts:
  - "*"
  gateways:
  - bookinfo-gateway
  http:
  - match:
    - uri:
        exact: /productpage
    - uri:
        prefix: /static
    - uri:
        exact: /login
    - uri:
        exact: /logout
    - uri:
        prefix: /api/v1/products
    route:
    - destination:
        host: productpage
        port:
          number: 9080

Nous avons plus qu’à appliquer le manifeste.

> kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml -n demo

gateway.networking.istio.io/bookinfo-gateway created
virtualservice.networking.istio.io/bookinfo created

Nous pouvons maintenant valider notre configuration avec istioctl.

> istioctl analyze -n demo

✔ No validation issues found when analyzing namespace: demo.

Affichons maintenant les services du namespace istio-system afin de récupérer l’adresse IP externe de notre istio-ingressgateway:

> kubectl get svc -n istio-system

Avec l’IP récupérer, il nous suffit d’utiliser curl ou un navigateur web pour confirmer que notre application est accessible depuis l’extérieur du cluster.

> curl http://[External-IP]:80/productpage

<!DOCTYPE html>
<html>
  <head>
    <title>Simple Bookstore App</title>
...
...
...

Observabilité

Nous avons vu dans le billet précédent, qu’un des avantages des services mesh est l’observabilité.
Istio fournit également une installation et configuration basique des outils d’observabilités suivants:

Nous pouvons profiter de cette facilité d’installation pour les tester et voir à quoi ils ressemblent.
Nous n’allons pas rentrer dans le détail de chaque outil, mais simplement en avoir une brève introduction.

> kubectl apply -f samples/addons

Jaeger

Jaeger est un outil de distrubted tracing qui fonctionne automatiquement peu importe le langage ou le framework utilisé dans notre application.
Avant de pouvoir voir quelque chose sur Jaeger, nous devons générer des trace en accédant au moins une fois à notre application.

> curl http://[External-IP]:80/productpage

Nous pouvons maintenant lancer le dashboard et visualiser nos traces.

> istioctl dashboard jaeger
http://localhost:16686

Grafana

Grafana est une solution open source de monitoring avec une très grande communauté qui partage une grande quantité de dashboard tout prêt.
Bien entendu, nous pouvons éditer des dashboards existants pour les faire correspondre à nos besoins ou en créer directement des nouveaux.

> istioctl dashboard grafana
http://localhost:3000

Sur la page de Grafana, nous devons nous rendre dans l’onglet dashboard puis dans le dossier istio.
Ouvrons le dashboard Istio Service et sélectionnons le service productpage.
Nous pouvons voir des métriques sur notre service.

Kiali

Kiali est une solution open source permettant d’observer le trafic réseau des microservices à l’intérieur de notre service mesh.
Régénérons un peu de trafic avant d’ouvrir le dashboard de Kiali et visualiser tout ça.

> curl http://[External-IP]:80/productpage
> istioctl dashboard kiali
http://localhost:20001/kiali

Il nous suffit de nous rendre dans le menu Graph et de sélectionner notre namespace demo dans la liste déroulante. Nous pouvons visualiser les relations entre nos différents services ainsi que le trafic réseau qui en découle.

Nettoyage

> kubectl delete -f samples/addons
> istioctl uninstall --purge
> kubectl delete ns istio-system
> kubectl delete -f samples/bookinfo/platform/kube/bookinfo.yaml -n demo

Conclusion

Grace a toutes les ressources fournies par Istio, nous avons été capables de configurer très rapidement Istio et le tester.

Ludovic Alarcon .

Passioné par Kubernetes, les technologies Cloud et le DevOps - Développeur Golang et Dotnet