Bonjour à tous!
Dans cet article, je souhaite partager l'une des façons d'exécuter des tests de performances JMeter dans OpenShift en utilisant Jenkins comme automatisation. Nous allons d'abord effectuer toutes les étapes nécessaires (créer ImageStreams
, BuildConfig
, Job
etc.) en mode manuel. Après cela, écrivons Jenkins Pipeline.
Comme point de départ, nous devrions avoir :
- exécution du cluster OpenShift (v3.11)
- Serveur Jenkins avec informations d'identification configurées pour fonctionner dans OpenShift
- файл
apache-jmeter-5.2.tgz
Comme tests, ce sera simple HTTP Request
sur ya.ru
en un seul flux.
Créer un projet dans OpenShift
Commençons par créer un nouvel environnement. Créons perftest
entouré d'une équipe :
$ oc new-project perftest --display-name="Performance Tests" --description="Performance Tests - JMeter"
Nous serons automatiquement transférés vers l'environnement nouvellement créé perftest
, vérifions qu'il en est bien ainsi :
$ oc project
Using project "perftest" on server "https://127.0.0.1:8443".
Création de stockage
Les rapports de tests seront stockés en commun avec le serveur Web et jmeter-meter
'un endroit - /jmeter/reports
.
Il est préférable de créer des Storajs maintenant, car les POD y seront liés jmeter-web
и jmeter-master
.
Vous trouverez des informations plus détaillées sur le stockage dans la documentation officielle
Créons des fichiers yaml pour PV
и PVC
.
pv.yaml
$ tee pv.yaml<<EOF
apiVersion: v1
kind: PersistentVolume
metadata:
name: jmeter-reports
spec:
capacity:
storage: 10Gi
accessModes:
- ReadWriteMany
glusterfs:
endpoints: glusterfs-cluster
path: /jmeter/reports
readOnly: false
persistentVolumeReclaimPolicy: Retain
EOF
pvc.yaml
$ tee pvc.yaml<<EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: jmeter-reports
spec:
accessModes:
- ReadWriteMany
resources:
requests:
storage: 10Gi
EOF
créons PV
и PVC
entouré d'OpenShift :
$ oc create -f pv.yaml -n perftest
$ oc create -f pvc.yaml -n perftest
Vérification de l'état de PVC
:
$ oc get pvc -n perftest
NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS AGE
jmeter-reports Bound pvc-b0e5f152-db4b-11ea-a497-566f75280024 10Gi RWX glusterfs-storage 8m
Voici à quoi cela ressemblera dans l'interface graphique :
Création d'une image de base JMeter
Passons à la création ImageStream
и BuildConfig
.
Vous pouvez trouver toutes les informations nécessaires dans la documentation -
La stratégie de construction d’image est Docker
d'une source locale.
Créons une image de base jmeter-base
, qui servira de base à jmeter-master
.
Dockerfile
FROM openjdk:8u212-jdk
ARG JMETER_VER="5.2"
ENV JMETER_HOME /jmeter/apache-jmeter-$JMETER_VER
ENV PATH $JMETER_HOME/bin:$PATH
RUN mkdir -p /jmeter/results
&& mkdir /jmeter/tests
WORKDIR /jmeter
COPY apache-jmeter-$JMETER_VER.tgz .
RUN tar -xzf $JMETER_HOME.tgz
&& rm $JMETER_HOME.tgz
&& ls -la
RUN sed -i s/#server.rmi.ssl.disable=false/server.rmi.ssl.disable=true/ $JMETER_HOME/bin/jmeter.properties
EXPOSE 60000
est.yaml
$ tee is.yaml<<EOF
apiVersion: v1
kind: ImageStream
metadata:
labels:
build: jmeter-base
name: jmeter-base
EOF
bc.yaml
$ tee bc.yaml<<EOF
apiVersion: v1
kind: BuildConfig
metadata:
name: jmeter-base
spec:
failedBuildsHistoryLimit: 5
nodeSelector: null
output:
to:
kind: ImageStreamTag
name: 'jmeter-base:latest'
postCommit: {}
resources: {}
runPolicy: Serial
source:
binary: {}
type: Binary
strategy:
dockerStrategy:
from:
kind: ImageStreamTag
name: 'openjdk:8u212-jdk'
type: Docker
successfulBuildsHistoryLimit: 5
EOF
Créons des objets IS
и BC
:
$ oc create -f is.yaml -n perftest
$ oc create -f bc.yaml -n perftest
Maintenant, assemblons l'image de base jmeter-base
:
$ oc start-build jmeter-base -n perftest --from-dir=. --follow
JMeter WEB
jmeter-web
Il s'agit d'un serveur Web Apache. Sa tâche est de fournir un répertoire avec les résultats des tests à visualiser.
Préparé Dockerfile
et fichier de configuration httpd.conf
. Pour directive DocumentRoot
ensemble de valeurs /jmeter/reports
, c'est à dire. le répertoire dans lequel les résultats des tests sont enregistrés.
Dockerfile
$ tee Dockerfile<<EOF
FROM httpd:2.4
COPY httpd.conf /usr/local/apache2/conf/httpd.conf
RUN chmod -R 777 /usr/local/apache2/logs
EXPOSE 8080
CMD ["httpd", "-D", "FOREGROUND"]
EOF
est.yaml
$ tee is.yaml<<EOF
apiVersion: v1
kind: ImageStream
metadata:
generation: 1
labels:
build: jmeter-web
name: jmeter-web
EOF
bc.yaml
$ tee bc.yaml<<EOF
apiVersion: v1
kind: BuildConfig
metadata:
name: jmeter-web
spec:
failedBuildsHistoryLimit: 5
nodeSelector: null
output:
to:
kind: ImageStreamTag
name: 'jmeter-web:latest'
runPolicy: Serial
source:
binary: {}
type: Binary
strategy:
dockerStrategy:
from:
kind: ImageStreamTag
name: 'httpd:2.4'
type: Docker
successfulBuildsHistoryLimit: 5
EOF
créons ImageStream
и BuildConfig
objets:
$ oc create -f is.yaml -n perftest
$ oc create -f bc.yaml -n perftest
Collecte d'une image de Dockerfile
:
$ oc start-build jmeter-web -n perftest --from-dir=. --follow
dc.yaml
$ tee dc.yaml<<EOF
apiVersion: apps.openshift.io/v1
kind: DeploymentConfig
metadata:
name: jmeter-web
spec:
replicas: 1
template:
metadata:
labels:
name: jmeter-web
spec:
containers:
- image: 172.30.1.1:5000/perftest/jmeter-web
name: jmeter-web
volumeMounts:
- mountPath: /jmeter/reports
name: jmeter-reports
ports:
- containerPort: 80
protocol: TCP
- containerPort: 8080
protocol: TCP
volumes:
- name: jmeter-reports
persistentVolumeClaim:
claimName: jmeter-reports
EOF
sc.yaml
$ tee sc.yaml<<EOF
apiVersion: v1
kind: Service
metadata:
labels:
app: jmeter-web
name: jmeter-web
spec:
ports:
- name: 8080-tcp
port: 8080
protocol: TCP
targetPort: 8080
selector:
deploymentconfig: jmeter-web
sessionAffinity: None
type: ClusterIP
EOF
Créons des objets Service
и DeploymentConfig
:
$ oc create -f sc.yaml -n perftest
$ oc create -f dc.yaml -n perftest
Jmeter-maître
Commençons par déployer le serveur Web Apache.
Ceci est le fichier Docker jmeter-master
'a, basé sur jmeter-base
, qui exécutera des tests et enregistrera les résultats dans le stockage.
Dockerfile
Dockerfile
pour jmeter-master
, basé sur jmeter-base
.
FROM jmeter-base
ARG JMETER_VER="5.2"
ENV JMETER_HOME /jmeter/apache-jmeter-$JMETER_VER
ENV PATH $JMETER_HOME/bin:$PATH
WORKDIR /jmeter
COPY run.sh /jmeter/
COPY tests/*.jmx /jmeter/tests/
RUN chmod +x /jmeter/run.sh
ENTRYPOINT ["/bin/bash"]
CMD ["/jmeter/run.sh"]
courir.sh
run.sh
c'est un script qui exécute JMeter et enregistre les résultats dans un répertoire files
.
Chaque fois que le script est lancé, il supprime les tests précédents, vous ne pouvez donc travailler qu'avec les données les plus récentes. Mais ce n’est pas un problème, car vous pouvez le modifier selon vos besoins.
#!/bin/bash
set -e
if [ -d "/jmeter/reports/files" ]
then
echo "Directory /jmeter/reports/files exist - OK"
else
echo "Creating /jmeter/reports/files directory"
mkdir /jmeter/reports/files
fi
if [ -d "/jmeter/reports/dashboards" ]
then
echo "Directory /jmeter/reports/dashboards exist"
else
echo "Creating /jmeter/reports/dashboards directory"
mkdir /jmeter/reports/dashboards
fi
echo "*** JMeter START Tests ***"
for item in $(ls -1 /jmeter/tests | grep jmx)
do
echo "*** Removing dashboard directory for $item"
rm -rdf /jmeter/reports/dashboards/${item}*
echo "*** Removing tests directory for $item"
rm -rdf /jmeter/reports/files/${item}*
echo "*** Testing a $item file ***"
jmeter -n -t /jmeter/tests/${item} -l /jmeter/reports/files/${item}-report.jtl -e -o /jmeter/reports/dashboards/${item}-dash
done
est.yaml
$ tee is.yaml<<EOF
apiVersion: image.openshift.io/v1
kind: ImageStream
metadata:
generation: 1
labels:
build: jmeter-master
name: jmeter-master
EOF
bc.yaml
$ tee bc.yaml<<EOF
apiVersion: build.openshift.io/v1
kind: BuildConfig
metadata:
name: jmeter-master
spec:
failedBuildsHistoryLimit: 5
nodeSelector: null
output:
to:
kind: ImageStreamTag
name: 'jmeter-master:latest'
runPolicy: Serial
source:
binary: {}
type: Binary
strategy:
dockerStrategy:
from:
kind: ImageStreamTag
name: 'jmeter-base:latest'
type: Docker
successfulBuildsHistoryLimit: 5
EOF
créons IS
и BC
objets:
$ oc create -f is.yaml -n perftest
$ oc create -f bc.yaml -n perftest
Nous collectons jmeter-master
image:
$ oc start-build jmeter-master -n perftest --from-dir=. --follow
Emploi
Job
les sont utilisés dans OpenShift
'e afin d'exécuter un ou plusieurs POD
et garantir leur réussite après l'exécution de la commande/du script.
$ tee job.yaml<<EOF
apiVersion: batch/v1
kind: Job
metadata:
name: jmeter-master
labels:
jobName: jmeter-master
spec:
completions: 1
parallelism: 1
template:
metadata:
name: jmeter-master
labels:
jobName: jmeter-master
spec:
containers:
- name: jmeter-master
image: 172.30.1.1:5000/perftest/jmeter-master:latest
volumeMounts:
- mountPath: /jmeter/reports
name: jmeter-reports
imagePullPolicy: Always
volumes:
- name: jmeter-reports
persistentVolumeClaim:
claimName: jmeter-reports
restartPolicy: Never
terminationGracePeriodSeconds: 30
EOF
Créer un objet Job
:
$ oc create -f job.yaml -n perftest
Vérifions l'état du travail :
$ oc get jobs -n perftest
NAME DESIRED SUCCESSFUL AGE
jmeter-master 1 1 5m
Pour supprimer Job
utilisons la commande :
$ oc delete jobs/jmeter-master -n perftest --ignore-not-found=true
Pipeline Jenkins
Maintenant l'automatisation. Reprenons les étapes :
git clone
oc whoami -t
oc start-build ...
oc delete jobs/jmeter-master
oc create -f job.yaml -n perftest
Vous trouverez ci-dessous un pipeline dans lequel le clonage, la suppression et la création d'OpenShift sont effectués. Job
's.
#!groovy
pipeline {
agent any
stages {
stage('Start Notifications') {
steps {
echo "Sending Email Notification"
}
post {
always {
echo "STARTED - Performance Tests"
mail(to: '[email protected]', from: "[email protected]", subject: "START - Performance Tests",mimeType: "text/html", body: "<strong>START - Performance Tests</strong><br /><br />Project: Name of Project<br />Environment: PerfTest<br />Build number: ${env.BUILD_NUMBER}<br />Build URL: ${env.BUILD_URL}"
}
}
}
stage('Git checkout') {
steps {
...
}
}
stage('Perf Tests') {
steps {
script {
sh '''
OC_CMD1="oc login -u=username -p=PASS -n=perftest
--server=https://...:8443"
$OC_CMD1
OC_TOKEN=`oc whoami -t`
OC_CMD2="oc --token=$OC_TOKEN --server=https://...:8443
start-build jmeter-master -n=perftest --from-dir=./master
--follow=true"
OC_CMD3="oc --token=$OC_TOKEN --server=https://...:8443
delete jobs/jmeter-master -n=perftest --ignore-not-found=true"
OC_CMD4="oc--token=$OC_TOKEN --server=https://...:8443
create -f ./master/job.yaml -n=perftest"
$OC_CMD2
$OC_CMD3
$OC_CMD4
'''
}
}
}
post {
failure {
echo "FAILED - Performance Tests"
mail(to: '[email protected]', from: "[email protected]", subject: "FAILED - Performance Tests",mimeType: "text/html", body: "<strong>FAILED - Performance Tests</strong><br /><br />Project: Name of Project<br />Environment: PerfTest<br />Build number: ${env.BUILD_NUMBER}<br />Build URL: ${env.BUILD_URL}"
}
success {
echo "SUCCESSED - Performance Tests"
mail(to: '[email protected]', from: "[email protected]", subject: "SUCCESSED - Performance Tests",mimeType: "text/html", body: "<strong>SUCCESSED - Performance Tests</strong><br /><br />Project: Name of Project<br />Environment: PerfTest<br />Build number: ${env.BUILD_NUMBER}<br />Build URL: ${env.BUILD_URL}"
}
}
}
}
Une fois que Pipeline aura terminé son exploitation, nous recevrons une notification par e-mail '[email protected]
à partir de [email protected]
.
En cliquant sur le lien files
, qui stocke les rapports de tests :
Contenu du fichier ya.HTTP.Request.jmx-report.jtk
:
timeStamp,elapsed,label,responseCode,responseMessage,threadName,dataType,success,failureMessage,bytes,sentBytes,grpThreads,allThreads,URL,Latency,IdleTime,Connect
1597311456443,569,Yandex - HTTP Request,200,Ok,Thread Group 1-1,text,true,,59449,220,1,1,https://ya.ru/,145,0,57
1597311456443,147,Yandex - HTTP Request-0,302,Found,Thread Group 1-1,,true,,478,110,1,1,http://ya.ru/,145,0,57
1597311456592,420,Yandex - HTTP Request-1,200,Ok,Thread Group 1-1,text,true,,58971,110,1,1,https://ya.ru/,370,0,259
Conclusion
Cet article présente l'une des options permettant d'exécuter des tests JMeter dans l'environnement OpenShift. Nous avons effectué toutes les étapes manuellement, après quoi nous avons créé Jenkins Pipeline pour automatiser le processus d'exécution des tests.
Sources et documentation
JMeter – Tests de charge distribués à l'aide de Docker Exécution de tests JMeter dans OpenShift à partir d'un pipeline Jenkins OpenShiftStockage persistant Constructions et flux d'images
Source: habr.com