Jenkins ist ein Open-Source [[automatisierung|Automatisierungstool]], das ursprünglich für die Continuous Integration (CI) und Continuous Delivery (CD) von Software entwickelt wurde. 

Jenkins basiert auf einer Client-Server-Architektur. Jenkins stellt eine Weboberfläche bereit, über die Entwickler zugreifen können. Konfiguration von Projekten, das Überwachen von Builds und Tests sowie das Anzeigen von Berichten.

  * **Continuous Integration**: Jenkins ermöglicht es Entwicklern, ihre Änderungen kontinuierlich in den Hauptentwicklungszweig einzufügen, indem sie Builds auslösen und Tests durchführen. Es unterstützt die Integration mit Versionskontrollsystemen wie Git, SVN und Mercurial.
  * **Automatisierte Tests**: Jenkins ermöglicht es Entwicklern, automatisierte Tests auszuführen, um sicherzustellen, dass der Code ordnungsgemäß funktioniert. Es kann verschiedene Testwerkzeuge und Frameworks integrieren, um Unit-Tests durchzuführen.
  * **Continuous Delivery**: Jenkins bietet Mechanismen für die kontinuierliche Bereitstellung von Software. Entwickler können Pipelines erstellen, die den Build-, Test- und Bereitstellungsprozess automatisieren.
  * **Plugins**: Jenkins verfügt über unzählige Plugins um zusätzliche Funktionen und Integrationen hinzuzufügen. Plugins kann man auch selbst schreiben.

Obwohl Jenkins ursprünglich für die Automatisierung von Softwareentwicklungsprozessen entwickelt wurde, kann es auch zur Automatisierung von Netzwerkaufgaben eingesetzt werden.


  * **Konfigurationsmanagement**: Jenkins kann verwendet werden, um Konfigurationsänderungen in Netzwerkgeräten automatisch durchzuführen. Durch die Integration mit Tools wie Ansible, Puppet oder Chef kann Jenkins Konfigurationsdateien generieren und auf Netzwerkgeräte übertragen. 
  * **Netzwerktests**: Jenkins kann verwendet werden, um automatisierte Netzwerktests durchzuführen. Durch die Integration von Selenium oder JUnit kann Jenkins Netzwerktests automatisch ausführen und Berichte generieren.
  * **Netzwerkerkennung**: Durch die Integration mit Tools wie SNMP (Simple Network Management Protocol) oder RESTful APIs kann Jenkins Netzwerkgeräte erkennen und Informationen wie Betriebssystemversion, Schnittstellenstatus und Auslastung sammeln. Dies kann helfen, ein genaues Inventar von Netzwerkgeräten zu erstellen und den Zustand der Netzwerkinfrastruktur zu überwachen. 
  * **Netzwerkfehlerbehebung**: Jenkins kann bei der Fehlerbehebung in Netzwerken unterstützen. Durch die Integration mit Überwachungstools wie Nagios oder Zabbix kann Jenkins Netzwerkereignisse überwachen und bei auftretenden Problemen automatische Reaktionen auslösen. Z.B Neustarten von Diensten und Netzwerkgeräten oder das Versenden von Benachrichtigungen.

=====Jenkinsfile=====

Pipelines kann man in einem Jenkinsfile definieren. Ein Jenkinsfile wird in Groovy geschrieben. 

<code groovy>
pipeline {
    agent any  // Definiert den Agenten, auf dem die Pipeline ausgeführt wird. "any" bedeutet, dass die Pipeline auf jedem verfügbaren Agenten ausgeführt werden kann.

    options {
        // Hier können globale Optionen für die Pipeline definiert werden, wie zum Beispiel die Timeout-Einstellungen.
    }

    environment {
        // Hier können Umgebungsvariablen für die Pipeline definiert werden, die während der Ausführung verwendet werden können.
    }

    stages {
        stage('Build') {
            steps {
                // Hier werden die Schritte definiert, die im Build-Stadium ausgeführt werden sollen.
            }
        }

        stage('Test') {
            steps {
                // Hier werden die Schritte definiert, die im Test-Stadium ausgeführt werden sollen.
            }
        }

        // Weitere Stufen können nach Bedarf hinzugefügt werden.

        post {
            always {
                // Hier werden die Schritte definiert, die immer ausgeführt werden, unabhängig vom Erfolg oder Fehler der vorherigen Stufen.
            }
            success {
                // Hier werden die Schritte definiert, die ausgeführt werden, wenn alle vorherigen Stufen erfolgreich abgeschlossen wurden.
            }
            failure {
                // Hier werden die Schritte definiert, die ausgeführt werden, wenn eine der vorherigen Stufen fehlschlägt.
            }
        }
    }
}
</code>

Groovy bietet auch Anweisungen wie z.B. Schleifen, Bedingungen, Funktionen, Parameter usw.

<code groovy>
def myGroovyFunction(param1, param2) {
    // Hier wird Ihre individuelle Logik und Berechnungen durchgeführt
    // Rückgabe des Ergebnisses
    return param1 + param2
}

pipeline {
    agent any

    parameters {
        groovyParam(defaultValue: 'default value', description: 'Beschreibung des Parameters', name: 'myParam', script: 'return myGroovyFunction("Hello", "World")')
    }

    stages {
        stage('Build') {
            steps {
                // Hier können Sie den Parameter `myParam` in Ihren Schritten verwenden
                script {
                    def result = myParam()
                    echo "Ergebnis der Groovy-Funktion: ${result}"
                }
            }
        }
    }
}
</code>
=====Build tools=====

  * gradle
  * maven
  * [[git|git]]
  * ant

=====Links=====

  * [[https://youtu.be/F_1AmlzP06U|Installation und Pipeline erstellen auf ubuntu]] 
  * [[https://youtu.be/woMAXn4e8NA|First steps tutorial]] 
  * [[https://www.youtube.com/playlist?list=PLy7NrYWoggjw_LIiDK1LXdNN82uYuuuiC|Jenkins beginner tutorial playlist]]
  * [[https://www.youtube.com/watch?v=7KCS70sCoK0|Jenkins file explained]]
  * [[https://www.youtube.com/watch?v=99DddJiH7lM|Create an agent node in jenkins]]
  * [[https://www.youtube.com/watch?v=Wj-weFEsTb0|Getting started with shared libraries]]
  * [[https://www.youtube.com/watch?v=bGDyGH13k1g|Another shared library tutorial]]
  * [[https://youtu.be/s73nhwYBtzE|Create jenkins pipeline]]