Utilisation de kube-burner sur OpenShift

Introduction

kube-burner est un outil en ligne de commande open-source conçu pour la création et la destruction de clusters et de ressources Kubernetes à grande échelle. Il simplifie la gestion et le déploiement d’environnements Kubernetes complexes, ce qui en fait un outil essentiel pour les ingénieurs DevOps, les administrateurs système et ceux impliqués dans les pipelines d’intégration et de livraison continues. Dans ce tutoriel, nous verrons comment utiliser kube-burner pour déployer une application de test simple sur Red Hat OpenShift.

Étape 1 : Installation de kube-burner

Pour commencer, nous devons télécharger et installer l’interface en ligne de commande kube-burner. Tout d’abord, clonons le dépôt depuis GitHub et installons le binaire en utilisant le Makefile :

git clone https://github.com/kube-burner/kube-burner.git
cd kube-burner
make
sudo make install

Étape 2 : Templates pour l’application de test

Maintenant, nous allons créer des templates YAML pour notre application de test, qui comprend un serveur web, un pod curl utilisé pour accéder au webserver, et deux networkPolicy : deny-by-default et allow-http.

git clone https://github.com/neutron-IT-organization/kube-burner.git
cd kube-burner

Les templates générés dans cette étape ont pour objectif de tester à grande échelle le fonctionnement des politiques réseau (network policy) dans un environnement Kubernetes. Pour ce faire, le pod curl est configuré avec un initContainer qui exécute une requête curl sur le serveur web. En récupérant le statut du pod curl, nous pourrons déterminer si les politiques réseau ont été appliquées correctement.

Étape 3 : Installation d’Elasticsearch, Kibana et Grafana

Pour pouvoir monitorer notre test, nous allons installer quelques opérateurs. Allez dans la console OpenShift et installez l’opérateur Elasticsearch (ECK) et l’opérateur Grafana.

Ensuite, appliquez les configurations ci-dessous pour les opérateurs.

cd dashboard
oc apply -f elastic.yaml -f kibana.yaml -f grafana.yaml

Enregistrez le mot de passe Elasticsearch et la route avec la commande ci-dessous.

oc get secret elasticsearch-kube-burner-es-elastic-user -n kube-burner \
   -o go-template --template="{{.data.elastic|base64decode}}"
oc get route -n kube-burner

Enfin, nous créons une ElasticSearchDataSource qui sera utilisé pour tracer le contenu des métriques générées à partir de l’index.era utilisé pour tracer le contenu des métriques générées à partir de l’index. (NOTE : renseignez le mot de passe elastic au lieu de YOURPASSWORD)

oc apply -f elasticGrafanaDataSource.yaml

Étape 4 : Configuration de kube-burner pour déployer l’application de test

Maintenant que nous avons nos templates YAML, utilisons kube-burner pour les déployer “at scale” dans OpenShift. Pour cela créez un fichier de configuration Kube-Burner pour déployer l’application de test en utilisant Kube-Burner. Commençons par définir la structure de base de notre fichier de configuration.

NOTE : mettez à jour le mot de passe et l’itinéraire d’elasticsearch avec ceux que vous avez obtenus à l’étape précédente.

---
global:
  indexerConfig:
    esServers: [https://elastic:YOURPASSWORD@YOUR_ES_ROUTE]
    insecureSkipVerify: true
    defaultIndex: kube-burner
    type: elastic
  measurements:
    - name: podLatency
jobs:
  - name: deny-all-policy
    jobIterations: 1
    qps: 1
    burst: 1
    namespacedIterations: false
    namespace: kubelet-density-cni-networkpolicy
    jobPause: 1m
    objects:

      - objectTemplate: templates/deny-all.yaml
        replicas: 1

  - name: kubelet-density-cni-networkpolicy
    jobIterations: 100
    qps: 25
    burst: 25
    namespacedIterations: false
    namespace: kubelet-density-cni-networkpolicy
    waitWhenFinished: true
    podWait: false
    preLoadImages: true
    preLoadPeriod: 2m
    objects:

      - objectTemplate: templates/ubi9-deployment.yaml
        replicas: 1

      - objectTemplate: templates/ubi9-service.yaml
        replicas: 1

      - objectTemplate: templates/allow-http.yaml
        replicas: 1

      - objectTemplate: templates/curl-deployment.yaml
        replicas: 1

Ce fichier de configuration configure plusieurs tâches avec des charges de travail variables (par exemple, une tâche « deny-all-policy », qui déploie une politique réseau refusant tout le trafic) et des ressources (telles que des déploiements et des services), et spécifie les paramètres pour chaque test (comme le nombre d’itérations, le QPS et le burst). L’outil kube-burner utilisera ensuite ce fichier de configuration pour créer, déployer et gérer ces ressources dans un cluster Kubernetes.

Maintenant, lancez votre test de benchmark avec la commande ci-dessous :

kube-burner init -m ./metrics.yaml -c ./network-policy-density.yaml -u https://$(oc get route prometheus-k8s -n openshift-monitoring -o jsonpath="{.spec.host}") --log-level=debug --token=$(oc create token prometheus-k8s -n openshift-monitoring)

Résultats

Après quelques minutes, vous devriez observer la création d’un namespace nommé kubelet-density-cni-networkpolicy avec un total de 200 pods : 100 pour le serveur web et 100 pour les pods curl utilisés pour les tests.

Pour visualiser les métriques associées à votre déploiement, accédez à Grafana et connectez-vous en utilisant les identifiants admin et hello. Ensuite, sélectionnez l’UUID généré en sortie de la commande kube-burner. Vous pourrez alors observer et analyser les différentes métriques liées à votre déploiement, ce qui vous permettra d’évaluer les performances et la stabilité de votre cluster Kubernetes.

Félicitations à tous ceux qui ont suivi ce guide jusqu’au bout ! Vous avez maintenant les connaissances nécessaires pour déployer et tester des applications à grande échelle sur Red Hat OpenShift en utilisant kube-burner. Continuez votre exploration et votre développement dans le monde passionnant de Kubernetes !