ProHoster > Blog > Administration > Ausführen von JMeter-Tests in OpenShift mit Jenkins Pipeline

Ausführen von JMeter-Tests in OpenShift mit Jenkins Pipeline

Hallo zusammen!

In diesem Artikel möchte ich eine der Methoden zum Starten von JMeter-Leistungstests in OpenShift mit Jenkins als Automatisierung vorstellen. Zunächst führen wir alle notwendigen Schritte manuell durch (Erstellung ImageStreams, BuildConfig, Auftrag und weitere) in manueller Weise. Danach schreiben wir eine Jenkins-Pipeline.

Als Ausgangspunkt benötigen wir:

  1. ein funktionierendes OpenShift (v3.11) Cluster
  2. einen Jenkins-Server mit konfigurierten Anmeldeinformationen für die Arbeit in OpenShift
  3. eine Datei apache-jmeter-5.2.tgz

Als Tests verwenden wir einen einfachen HTTP-Anfrage findet man ya.ru in einem Thread.

Erstellung eines Projekts in OpenShift

Beginnen wir mit der Erstellung einer neuen Umgebung. Wir erstellen perftest Umgebung mit dem Befehl:

$ oc new-project perftest --display-name="Leistungstests" --description="Leistungstests - JMeter"

Wir werden automatisch in die gerade erstellte Umgebung weitergeleitet perftest, prüfen wir, ob das so ist:

$ oc project
Using project "perftest" on server "https://127.0.0.1:8443".

Erstellung eines Speichers

Die Testergebnisse werden gemeinsam für den Webserver und jmeter-meteran einem Ort gespeichert — /jmeter/reports.

Es ist besser, die Speichersysteme jetzt zu erstellen, da die PODs jmeter-web und jmeter-master.

Darüber hinaus finden Sie detaillierte Informationen zu Speichersystemen in der offiziellen Dokumentation Persistenter Speicher.

Erstellen wir yaml-Dateien für PV und 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

Lassen Sie uns PV und PVC in der OpenShift-Umgebung:

$ oc create -f pv.yaml -n perftest
$ oc create -f pvc.yaml -n perftest

Überprüfen Sie den Status für 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

So sieht es im GUI aus:

Ausführen von JMeter-Tests in OpenShift mit Jenkins Pipeline

Erstellung eines Basis-Images für JMeter

Lassen Sie uns mit der Erstellung beginnen ImageStream und BuildConfig.

Alle notwendigen Informationen finden Sie in der Dokumentation — Builds und Image Streams.

Die Build-Strategie für die Images verwendet Docker aus einer lokalen Quelle.

Erstellen wir das Basis-Image jmeter-base, das die Grundlage für 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

is.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

Lassen Sie uns die Objekte erstellen IS und BC:

$ oc create -f is.yaml -n perftest
$ oc create -f bc.yaml -n perftest

Jetzt erstellen wir das Basissbild jmeter-base:

$ oc start-build jmeter-base -n perftest --from-dir=. --follow

JMeter WEB

jmeter-web ist ein Apache-Webserver. Seine Aufgabe ist es, ein Verzeichnis mit Testergebnissen zur Ansicht bereitzustellen.

Vorbereitung Dockerfile und die Konfigurationsdatei httpd.conf. Für die Direktive DocumentRoot wurde der Wert /jmeter/reportsfestgelegt, d.h. das Verzeichnis, in dem die Testergebnisse gespeichert werden.

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

is.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

Lassen Sie uns ImageStream und BuildConfig Objekte:

$ oc create -f is.yaml -n perftest
$ oc create -f bc.yaml -n perftest

Wir erstellen ein Image aus 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

Lassen Sie uns die Objekte erstellen Service und DeploymentConfig:

$ oc create -f sc.yaml -n perftest
$ oc create -f dc.yaml -n perftest

Jmeter-master

Lassen Sie uns mit dem Deployment des Apache-Webservers beginnen.

Dies ist das Dockerfile jmeter-master‘a, basierend auf jmeter-base, das Tests ausführen und die Ergebnisse im Storage speichern wird.

Dockerfile

Dockerfile für jmeter-master, basierend auf jmeter-base.

VON 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"]

run.sh

run.sh Dies ist ein Skript, das JMeter ausführt und die Ergebnisse im Verzeichnis speichert. files.

Bei jedem Ausführen des Skripts werden die vorherigen Tests gelöscht, sodass immer nur mit den aktuellen Daten gearbeitet werden kann. Das ist jedoch kein Problem, da es an Ihre Bedürfnisse angepasst werden kann.

#!/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

is.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

Lassen Sie uns IS und BC Objekte:

$ oc create -f is.yaml -n perftest
$ oc create -f bc.yaml -n perftest

Wir bauen jmeter-master Image:

$ oc start-build jmeter-master -n perftest --from-dir=. --follow

Auftrag

Auftrag‘ys werden verwendet, um OpenShift‘e um einen oder mehrere PODs‘s auszuführen und deren erfolgreiche Ausführung nach dem Ausführen des Befehls/Skripts zu garantieren.

$ 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

Erstellen eines Objekts Auftrag:

$ oc create -f job.yaml -n perftest

Überprüfen wir den Status des Jobs:

$ oc get jobs -n perftest
NAME            DESIRED   SUCCESSFUL   AGE
jmeter-master   1         1            5m

Um zu löschen Auftrag verwenden wir den Befehl:

$ oc delete jobs/jmeter-master -n perftest --ignore-not-found=true

Jenkins-Pipeline

Jetzt die Automatisierung. Lassen Sie uns die Schritte noch einmal durchgehen:

  1. git clone
  2. oc whoami -t
  3. oc start-build ...
  4. oc delete jobs/jmeter-master
  5. oc create -f job.yaml -n perftest

Im Folgenden ist die Pipeline dargestellt, in der das Klonen des Repositories sowie das Löschen und Erstellen von OpenShift durchgeführt wird. Auftrag‘s.

#!groovy

pipeline {

    agent any

    stages {

        stage('Start Notifications') {
            steps {
                echo "Sending Email Notification"
            }
            post {
                always {
                    echo "STARTED - Performance Tests"
                    mail(to: 'username@srv.net', from: "jenkins@srv.net", subject: "START - Performance Tests",mimeType: "text/html", body: "<strong>START - Leistungstests</strong><br /><br />Projekt: Name des Projekts<br />Umgebung: PerfTest<br />Build-Nummer: ${env.BUILD_NUMBER}<br />Build-URL:   ${env.BUILD_URL}"
                }
            }
        }

        phase('Git-Checkout') {
            Schritte {
                ...
            }
        }

        phase('Leistungstests') {
            Schritte {
                Skript {
                    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
                    '''
                }
            }
        }

        nachher {
            fehler {
                echo "GESCHEITERT - Leistungstests"
                mail(to: 'username@srv.net', from: "jenkins@srv.net", subject: "GESCHEITERT - Leistungstests",mimeType: "text/html", body: "<strong>GESCHEITERT - Leistungstests</strong><br /><br />Projekt: Name des Projekts<br />Umgebung: PerfTest<br />Build-Nummer: ${env.BUILD_NUMBER}<br />Build-URL: ${env.BUILD_URL}"
                }

            erfolg {
                echo "ERFOLGREICH - Leistungstests"
                mail(to: 'username@srv.net', from: "jenkins@srv.net", subject: "ERFOLGREICH - Leistungstests",mimeType: "text/html", body: "<strong>ERFOLGREICH - Leistungstests</strong><br /><br />Projekt: Name des Projekts<br />Umgebung: PerfTest<br />Build-Nummer: ${env.BUILD_NUMBER}<br />Build-URL:   ${env.BUILD_URL}"
            }
        }

    }
}

Nachdem die Pipeline abgeschlossen ist, erhalten wir eine Benachrichtigung per E-Mail. 'username@srv.net ab jenkins@srv.net.

Wenn Sie dem Link folgen http://jmeter-web.127.0.0.1.nip.io/ sehen wir das Verzeichnis files, in dem die Testberichte gespeichert sind:

Ausführen von JMeter-Tests in OpenShift mit Jenkins Pipeline

Inhalt der Datei 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-Anfrage,200,Ok,Thread Gruppe 1-1,text,true,,59449,220,1,1,https://ya.ru/,145,0,57
1597311456443,147,Yandex - HTTP-Anfrage-0,302,Gefunden,Thread Gruppe 1-1,,true,,478,110,1,1,http://ya.ru/,145,0,57
1597311456592,420,Yandex - HTTP-Anfrage-1,200,Ok,Thread Gruppe 1-1,text,true,,58971,110,1,1,https://ya.ru/,370,0,259

Fazit

In diesem Artikel wird eine der Methoden zur Ausführung von JMeter-Tests in einer OpenShift-Umgebung demonstriert. Wir haben alle Schritte manuell durchgeführt und anschließend eine Jenkins-Pipeline zur Automatisierung des Teststarts erstellt.

Quellen und Dokumentation

Quelle: habr.com

Zuverlässiges Webhosting mit DDoS-Schutz, VPS- und VDS-Server kaufen 🔥 Zuverlässiges Webhosting mit DDoS-Schutz, VPS- und VDS-Server kaufen | ProHoster