Nous vivons dans un monde où rien ne reste immobile. Dans le monde informatique en évolution rapide, les entreprises s’efforcent de mettre au point des systèmes distribués évolutifs et tolérants aux pannes, et pas seulement en ce qui concerne le développement de logiciels. De nombreuses transformations numériques se produisent également dans le domaine de l'assurance de la qualité. Les entreprises se concentrent davantage sur la manière dont elles peuvent automatiser leurs processus de test pour les rendre plus rapides, plus faciles à configurer et plus efficacement déployés.    

Sélénium Grid: avantages et inconvénients    

En ce qui concerne l’automatisation des applications Web, Selenium Grid est devenu le premier élément fondamental des jeux d’outils révolutionnaires, permettant de réaliser des tests Selenium sur différentes machines et avec plusieurs navigateurs simultanément. Dans le bon vieux temps, il suffisait de brancher deux ordinateurs ensemble, d'exécuter deux scripts d'agent Selenium sur chacun de ces ordinateurs et c'était tout. Mais rien ne reste toujours valable dans sa forme initiale, et la solution d’automatisation très populaire «Selenium Grid» a maintenant été mise à l’épreuve. Mais avant de passer à la partie la plus intéressante, réfléchissons à ce qui n’était pas parfait dans l’infrastructure de Selenium Grid dans sa forme originale:  

  • La grille a un ‘talon d’Achille’ - Selenium Hub: le concept hub-and-node a un gros point faible: Selenium Hub. Selenium Hub est un point d'accès de navigateur unique qui rend tous les nœuds indisponibles lorsque le concentrateur tombe en panne.
  • Selenium Grid n’évolue pas très bien: c’est un fait bien connu que le concentrateur Selenium ne peut gérer qu’un nombre limité de nœuds connectés.
  • Infrastructure obsolète pour les tests en cours: Les nœuds Selenium Grid se retrouvent généralement dans un état médiocre, laissant le système en marche assez longtemps. Par conséquent, le redémarrage du noeud correspond exactement à ce que le médecin a demandé, mais cela ne peut être fait que manuellement.
  • Synchronisation de version frustrante: Garder le projet à jour avec la dernière version de Selenium et le synchroniser avec la version du navigateur et du WebDriver peut entraîner des difficultés et prendre du temps. La maintenance et les mises à jour de la grille sont un processus fastidieux noeud par noeud.  

Présentation de Zalenium    

C'est là que Zalenium entre en scène! Selon sa page officielle, Zalenium est une grille de sélénium flexible et évolutive basée sur un conteneur, avec enregistrement vidéo, aperçu en direct, authentification de base et tableau de bord. De plus, il dispose d'une intégration prête à l'emploi de Docker et Kubernetes. Ce fait fait de Zalenium un choix attrayant pour mettre en place une infrastructure basée sur Selenium.  

En creusant dans Zalenium, vous réaliserez tous les avantages qu’il apporte à l’automatisation Web.

Intégration Sélénium / Zalénium-Kubernetes  

Une intégration prête à l'emploi avec Kubernetes réduit considérablement le temps d'exécution des tests en créant des conteneurs Docker des navigateurs Web nécessaires et en les exécutant en parallèle. Cela signifie en fait une mise à l'échelle horizontale de vos tests. De plus, cela vous évite les maux de tête de la configuration et de la maintenance de la grille. Par conséquent, vous n’avez pas à traiter directement avec les conteneurs / pods. Au lieu de cela, Kubernetes gère automatiquement l'état souhaité du système.     L'exécution de Zalenium dans un cluster Kubernetes devient une solution puissante pour mettre en place une infrastructure basée sur Selenium de manière plus efficace et plus simple. C’est particulièrement vrai si vous avez déjà orchestré, livré et exécuté le logiciel de la société avec Kubernetes. Plongeons-nous dans Zalenium et tirons parti de son intégration à Kubernetes. La configuration souhaitée est représentée dans le diagramme ci-dessous.

Configuration du cluster Kubernetes sur la machine locale    

Création de notre test Zalenium-Kubernetes à base de sélénium. La principale condition préalable à cette configuration est d'avoir un cluster Kubernetes en cours d'exécution. Pour expérimenter avec Kubernetes localement, vous pouvez utiliser Minikube. Minikube est un outil qui permet de créer un cluster virtuel à nœud unique sur votre ordinateur. Le moyen le plus simple de configurer Minikube sur un Mac consiste à exécuter la commande d'infusion suivante (les étapes d'installation pour les autres plates-formes sont disponibles ici):

MacBook-Pro-de-admin:~ admin$ brew cask install minikube

En cas d'installation séparée de Kubectl, utilisez les instructions fournies dans la documentation officielle.

MBP-de-admin:~ admin$ minikube start
😄  minikube v1.3.1 on Darwin 10.14.6
💿  Downloading VM boot image ...
minikube-v1.3.0.iso.sha256: 65 B / 65 B [--------------------] 100.00% ? p/s 0s
minikube-v1.3.0.iso: 49.81 MiB / 131.07 MiB [->__] 38.00% 1.23 MiB p/s ETA 1m5s
🔥  Creating virtualbox VM (CPUs=2, Memory=2000MB, Disk=20000MB) ...
🐳  Preparing Kubernetes v1.15.2 on Docker 18.09.8 ...
💾  Downloading kubeadm v1.15.2
💾  Downloading kubelet v1.15.2
🚜  Extrayant les images ... 
🚀  Lançant Kubernetes ...
⌛  Waiting for: apiserver proxy etcd scheduler controller dns
🏄  Fini! kubectl est maintenant configuré pour utiliser "minikube".

Cela va démarrer un cluster local Kubernetes.

MBP-de-admin:~ admin$ minikube status
host: Running
kubelet: Running
apiserver: Running
kubectl: Correctly Configured: pointing to minikube-vm at 192.168.99.100

Vérifiez l'état et l'adresse IP du cluster.

Cas N°1 : Exécution de Zalenium sur le cluster Kubernetes    

Afin de faire tourner Zalenium dans Kubernetes, nous devons extraire des images de Zalenium et de Selenium Docker à l’intérieur du cluster. Pour que cela soit possible, nous devons basculer Docker vers le contexte Kubernetes en exécutant la commande docker-env.

MBP-de-admin:~ admin$ minikube docker-env
export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.99.100:2376"
export DOCKER_CERT_PATH="/Users/admin/.minikube/certs"
# Run this command to configure your shell:
# eval $(minikube docker-env)

Ceci fournira une commande pour utiliser Docker à partir de la ligne de commande de votre ordinateur local contre la machine virtuelle Kubernetes.

MBP-de-admin:~ admin$ eval $(minikube docker-env)

Téléchargeons les images Selenium et Zalenium Docker pour les faire tourner dans le cluster.

MBP-de-admin:~ admin$ docker pull elgalu/selenium

docker pull dosel/zalenium

Comme mentionné précédemment, les techos de Zalando ont déjà préparé tous les scripts nécessaires pour exécuter Zalenium avec Kubernetes à l'aide d'une commande d'une ligne.

MBP-de-admin:~ admin$ git clone https://github.com/zalando/zalenium
cd zalenium

Créer le déploiement dans Minikube :

kubectl create namespace zalenium
helm init --client-only
helm template --name zalenium \
    --set hub.serviceType=NodePort \
    charts/zalenium | kubectl -n zalenium apply -f -

Accédez au tableau de bord Minikube et vérifiez le déploiement, ouvrez également la console de Grid :

# Dashboard
minikube dashboard
# Grid Console
minikube service --namespace zalenium zalenium

Ce qui donne :

et pour la console de Grid :

at :

Vérifications en ligne de commande :

MBP-de-admin:zalenium admin$ kubectl get pods --all-namespaces
NAMESPACE     NAME                                    READY   STATUS    RESTARTS   AGE
kube-system   coredns-5c98db65d4-25p8j                1/1     Running   0          6h41m
kube-system   coredns-5c98db65d4-56klq                1/1     Running   0          6h41m
kube-system   etcd-minikube                           1/1     Running   0          6h40m
kube-system   kube-addon-manager-minikube             1/1     Running   0          6h40m
kube-system   kube-apiserver-minikube                 1/1     Running   0          6h40m
kube-system   kube-controller-manager-minikube        1/1     Running   0          6h40m
kube-system   kube-proxy-wdtkt                        1/1     Running   0          6h41m
kube-system   kube-scheduler-minikube                 1/1     Running   0          6h40m
kube-system   kubernetes-dashboard-7b8ddcb5d6-cl7b6   1/1     Running   0          51m
kube-system   storage-provisioner                     1/1     Running   0          6h41m
zalenium      zalenium-40000-2w6rs                    1/1     Running   0          51m
zalenium      zalenium-40000-hlxpz                    1/1     Running   0          51m
zalenium      zalenium-5c6649b4bf-zw8jl               1/1     Running   0          51m
MBP-de-admin:zalenium admin$ minikube service --namespace zalenium zalenium
|-----------|----------|-----------------------------|
| NAMESPACE |   NAME   |             URL             |
|-----------|----------|-----------------------------|
| zalenium  | zalenium | http://192.168.99.100:31287 |
|-----------|----------|-----------------------------|
🎉  Opening kubernetes service  zalenium/zalenium in default browser...

Exécution de web-tests avec Zalenium    

Après avoir configuré Zalenium, ouvrez le service zalenium/zalenium dans le navigateur par défaut via la commande vue ci-dessus :

minikube service zalenium --namespace zalenium     

Vous pouvez obtenir une URL du service déployé sur Kubernetes à l'aide de la commande suivante:

Désormais, il vous suffit d'indiquer à la configuration de Selenium WebDriver l'utilisation de cette URL pour exécuter vos tests avec Zalenium.

Lancement de Selenium en tant que service sur un cluster k8s

MBP-de-admin:~ admin$ kubectl run selenium-hub --image selenium/hub:3.10.0 --port 4444
kubectl run --generator=deployment/apps.v1 is DEPRECATED and will be removed in a future version. Use kubectl run --generator=run-pod/v1 or kubectl create instead.
deployment.apps/selenium-hub created
MBP-de-admin:~ admin$ kubectl get pods
NAME                            READY   STATUS    RESTARTS   AGE
selenium-hub-864ccd6ccb-rxhxr   1/1     Running   0          13m

Faire tourner le noeud Chrome en tant que déploiement sur un cluster k8s

kubectl run selenium-node-chrome --image selenium/node-chrome:3.10.0 --env="HUB_PORT_4444_TCP_ADDR=selenium-hub" --env="HUB_PORT_4444_TCP_PORT=4444"
deployment "selenium-node-chrome" created

Cas N°2 d'installation : Lancement de sélénium en tant que service sur un cluster k8s

Nous allons utiliser un cluster Kubernetes à nœud unique avec Minikube. Minikube exécute un cluster Kubernetes à un seul nœud dans une machine virtuelle de votre ordinateur portable pour les utilisateurs qui souhaitent faire l'essai de cas d'utilisation de Kubernetes en tant que POC.

Conditions préalables

Nous devons d’abord installer le cluster Kubernetes localement sur votre ordinateur. Pour rappel :

minikube start 

minikube status
host: Running
kubelet: Running
apiserver: Running
kubectl: Correctly Configured: pointing to minikube-vm at 192.168.99.101

Les noeuds disponibles

MBP-de-admin:~ admin$ kubectl get nodes
NAME       STATUS   ROLES    AGE   VERSION
minikube   Ready    master   14h   v1.15.2

Les dernières images de Selenium Docker sont disponibles ici dans ce lien ci-dessous Docker images for Selenium

MBP-de-admin:~ admin$ kubectl run selenium-hub --image selenium/hub:3.10.0 --port 4444
kubectl run --generator=deployment/apps.v1 is DEPRECATED and will be removed in a future version. Use kubectl run --generator=run-pod/v1 or kubectl create instead.
deployment.apps/selenium-hub created

Faire tourner le noeud Chrome en tant que déploiement sur un cluster k8s

MBP-de-admin:~ admin$ kubectl run selenium-node-chrome --image selenium/node-chrome:3.10.0 --env="HUB_PORT_4444_TCP_ADDR=selenium-hub" --env="HUB_PORT_4444_TCP_PORT=4444"
kubectl run --generator=deployment/apps.v1 is DEPRECATED and will be removed in a future version. Use kubectl run --generator=run-pod/v1 or kubectl create instead.
deployment.apps/selenium-node-chrome created

Faire tourner le nœud Firefox en déploiement sur un cluster k8s

MBP-de-admin:~ admin$ kubectl run selenium-node-firefox --image selenium/node-firefox:3.10.0 --env="HUB_PORT_4444_TCP_ADDR=selenium-hub" --env="HUB_PORT_4444_TCP_PORT=4444"
kubectl run --generator=deployment/apps.v1 is DEPRECATED and will be removed in a future version. Use kubectl run --generator=run-pod/v1 or kubectl create instead.
deployment.apps/selenium-node-firefox created

Scaler les déploiements

Mise à l'échelle des noeuds chrome avec sélénium

MBP-de-admin:~ admin$ kubectl scale deployment selenium-node-chrome --replicas=2
deployment.extensions/selenium-node-chrome scaled
MBP-de-admin:~ admin$  kubectl get pods
NAME                                    READY   STATUS    RESTARTS   AGE
selenium-hub-864ccd6ccb-wglvl           1/1     Running   0          7m37s
selenium-node-chrome-7fdb64f8fd-dd6sj   1/1     Running   0          7m24s
selenium-node-chrome-7fdb64f8fd-q82ts   1/1     Running   0          7m1s
selenium-node-firefox-5cd659477-gkpr2   1/1     Running   0          7m10s

Exposer le hub de sélénium pour qu'il soit accessible

$ kubectl expose deployment selenium-hub --type=NodePort
service "selenium-hub" exposed
$ kubectl get services
NAME           CLUSTER-IP   EXTERNAL-IP   PORT(S)          AGE
kubernetes     10.96.0.1     <none>        443/TCP          2m
selenium-hub   10.107.134.138   <nodes>    4444:32629/TCP   46s
  • Vous pouvez accéder à l’URL du sélénium via:
MBP-de-admin:~ admin$ minikube service selenium-hub --url
http://192.168.99.101:32325

Instances Chrome et Firefox après avoir scalé la console Selenium :

Dashboard

minikube dashboard

2. Configuration de sélénium Grid K8S à l’aide de Google Container Registry

Fichiers d'image Yaml pour Selenium Google Container Engine est également un moyen rapide de rendre Kubernetes opérationnel:

https://cloud.google.com/container-engine/

Votre cluster doit disposer de 4 processeurs et de 6 Go de RAM pour compléter l'exemple (4 instances). ) partie de mise à l'échelle. Lancer le sélénium en tant que service.

$ kubectl create -f selenium-hub-deployment.yaml

Créer un service pour que les nœuds se connectent :

$ kubectl create -f selenium-hub-svc.yaml

Spin up Chrome & Firefox Nodes

Maintenant que le hub est en place et exposé, il permet de créer des noeuds et de s’enregistrer dans le hub

$ kubectl create -f selenium-node-chrome-deployment.yaml
$ kubectl create -f selenium-node-firefox-deployment.yaml

Maintenant, les nœuds sont en place et enregistrés dans le hub créé ci-dessus.

Self-Healing Capability

Le self-healing est l'un des plus grands avantages de kubernetes. Bien que Docker-swarm prenne également en charge le self-healing, kubernetes est une solution plus fiable sur une période de temps en raison des contrôleurs de réplication. Pour démonstration, obtenons la liste des pods créés,

MBP-de-admin:test-selenium admin$ kubectl get pods
NAME                                    READY   STATUS    RESTARTS   AGE
selenium-hub-864ccd6ccb-wglvl           1/1     Running   0          2d23h
selenium-node-chrome-7fdb64f8fd-dd6sj   1/1     Running   0          2d23h
selenium-node-chrome-7fdb64f8fd-q82ts   1/1     Running   0          2d23h
selenium-node-firefox-5cd659477-gkpr2   1/1     Running   0          2d23h

Supprimons un noeud Google Chrome en utilisant la commande ci-dessous,

MBP-de-admin:test-selenium admin$ kubectl delete pod selenium-node-chrome-7fdb64f8fd-dd6sj 
pod "selenium-node-chrome-7fdb64f8fd-dd6sj" deleted

Maintenant, obtenez à nouveau la liste des pods (nœuds chrome)

MBP-de-admin:test-selenium admin$ kubectl get pods
NAME                                    READY   STATUS    RESTARTS   AGE
selenium-hub-864ccd6ccb-wglvl           1/1     Running   0          2d23h
selenium-node-chrome-7fdb64f8fd-5wmdf   1/1     Running   0          8s
selenium-node-chrome-7fdb64f8fd-q82ts   1/1     Running   0          2d23h
selenium-node-firefox-5cd659477-gkpr2   1/1     Running   0          2d23h

Pour regarder les logs sur un pod spécifique :

MBP-de-admin:test-selenium admin$ kubectl logs selenium-node-chrome-7fdb64f8fd-5wmdf 
16:07:42.622 INFO [GridLauncherV3.launch] - Selenium build info: version: '3.10.0', revision: '176b4a9'
16:07:42.630 INFO [GridLauncherV3$3.launch] - Launching a Selenium Grid node on port 5555
2019-09-04 16:07:42.967:INFO::main: Logging initialized @1471ms to org.seleniumhq.jetty9.util.log.StdErrLog
16:07:43.315 INFO [SeleniumServer.boot] - Selenium Server is up and running on port 5555
16:07:43.316 INFO [GridLauncherV3$3.launch] - Selenium Grid node is up and ready to register to the hub
16:07:43.338 INFO [SelfRegisteringRemote$1.run] - Starting auto registration thread. Will try to register every 5000 ms.
16:07:43.339 INFO [SelfRegisteringRemote.registerToHub] - Registering the node to the hub: http://selenium-hub:4444/grid/register
16:07:44.027 INFO [SelfRegisteringRemote.registerToHub] - Updating the node configuration from the hub
16:07:44.135 INFO [SelfRegisteringRemote.registerToHub] - The node is registered to the hub and ready to use

Nous pouvons constater qu'en quelques secondes, le contrôleur de réplication du hub sélénium génère automatiquement un nouveau nœud ou pod chrome sélénium-nœud-chrome-xxxx et s’assigne lui-même. Le contrôleur de réplication est l’un des atouts majeurs de kubernetes pour la gestion automatique des nœuds dans un cluster.

Dimensionnement et gestion de la mémoire dans le cluster K8

La mémoire idéale pour les pods Kubernates doit correspondre à 1,5 Go pour Chrome et Firefox.

“resources”: {“limits”: {“cpu”: “500m”,“memory”: “1536Mi”}}

Avantages:

  1. configuration rapide rapide et solution plus évolutive
  2. moins de maintenance et haute disponibilité
  3. capacité de self-healing
  4. facile à mettre à jour pour les changements de version
  5. élimine les problèmes de latence car il réside dans le même réseau