Automatisierungsserver: Semaphore UI vs. Jenkins

Denis GukovGründer und CTO bei Semaphore UI
18 Min. Lesezeit

Jenkins und Semaphore UI führen viele der gleichen Automatisierungswerkzeuge aus, organisieren die Arbeit darum herum jedoch unterschiedlich. Jenkins verbindet Builds, Tests und Deployments über Jobs, Pipelines und Plugins. Semaphore UI bringt Ansible, Terraform/OpenTofu, Terragrunt, Bash, PowerShell und Python in einem gemeinsamen Dienst zusammen, um Infrastrukturoperationen vorzubereiten, auszuführen und zu delegieren. Dieser Vergleich behandelt Jenkins 2.580.1 LTS und Semaphore UI 2.20.0.

Diesen Artikel mit KI besprechen

Übersicht

Automatisierung beginnt meist mit funktionierendem Code: einem Playbook, das Server patcht, einem Terraform-Projekt, das eine Umgebung erstellt, oder einem Befehl, der einen Dienst neu startet. Ihn zu teilen bringt weitere Entscheidungen mit sich. Jemand muss die Ziele auswählen, Zugangsdaten bereitstellen, die zwischen den Ausführungen wechselnden Werte erfassen und das Ergebnis für Kolleginnen und Kollegen verfügbar machen. Eine Release-Pipeline und eine Betriebsoberfläche können diese Arbeit leisten, ordnen sie dabei aber unterschiedlich an.

Jenkins ist ein erweiterbarer Automatisierungsserver, der weit verbreitet für Continuous Integration und Delivery eingesetzt wird. Freestyle-Jobs konfigurieren Build-Schritte über die Oberfläche, während ein Jenkinsfile eine Pipeline als versionierten Code beschreibt. Agenten führen die Arbeit aus, und Plugins ergänzen Werkzeugintegrationen, Autorisierung, Berichte und den Umgang mit Artefakten. Dasselbe Job-Modell unterstützt auch geplante Prüfungen und manuell gestartete Infrastrukturprozeduren.

Semaphore UI organisiert die Prozedur rund um ein Task Template. Die Vorlage wählt ein Automatisierungswerkzeug und ein Repository aus und verbindet dann die Einstellungen, die diese Operation benötigt. Für Ansible gehören dazu ein Inventar, Zugangsdaten und Variablengruppen. Eingabeformulare erfassen Werte beim Start, Zeitpläne wiederholen die Operation und Workflows verbinden mehrere Vorlagen. Die Automatisierung bleibt in Git, während die Oberfläche dem Team eine gemeinsame Art der Nutzung gibt.

Kurzvergleich

Beide können ein Playbook auf Anforderung oder nach Zeitplan starten. Die Unterschiede werden deutlicher, wenn dieses Playbook für mehrere Umgebungen wiederverwendet, an eine andere Person im Team übergeben oder mit Provisionierung kombiniert werden muss.

Jenkins und Semaphore UI: zentrale Merkmale
Kriterien Semaphore UI Jenkins
Automatisierungstools Vorlagen für Ansible, Terraform/OpenTofu, Terragrunt, Bash, PowerShell und Python Befehlszeilenwerkzeuge und von Plugins bereitgestellte Build-Schritte
Installation Binary, native Pakete, Docker, Kubernetes WAR-Paket, native Pakete, Docker, Kubernetes
Ausführung Auf dem Server oder auf Runnern Agenten, einschließlich containerbasierter Umgebungen
Ansible-Inventar Gemeinsam genutzte statische oder Git-basierte Inventories, Ansible-Discovery-Plugins Inventar über das Ansible-Plugin oder den Job konfiguriert
Job-Einrichtung Werkzeugspezifische Task Templates In der UI konfigurierte Jobs und Jenkinsfile-Pipelines
Eingaben und Variablen Eingabeformulare und wiederverwendbare Variablengruppen Job-Parameter, Pipeline-Variablen und Konfiguration als Code
Workflows Visueller Graph, der Task Templates verbindet Declarative oder Scripted Pipeline, wiederverwendbare Libraries
Terraform-State Externes Backend oder integriertes HTTP-Backend in Pro Backend vom Terraform-Prozess konfiguriert
Zugangsdaten Key Store und Integrationen externer Secret-Stores Credentials-Store, Bindings und Secret-Store-Plugins
Zugriffskontrolle Projektrollen, benutzerdefinierte Rollen in Enterprise und Vorlagenberechtigungen Konfigurierbare Autorisierung, einschließlich projektbasierter Berechtigungen
Lizenz MIT Community, kommerzielles Pro und Enterprise MIT-Kern, einzelne Plugin-Lizenzen

Für eine routinemäßige Ansible-Operation hält Semaphore UI das Playbook, die Ziele, die Verbindungs-Zugangsdaten und die gemeinsame Konfiguration zusammen. Ein Staging-Deployment, eine Zertifikatsprüfung und ein Dienst-Neustart können diese Projektressourcen wiederverwenden und dabei unterschiedliche Startformulare anzeigen. Jenkins kann dieselben Operationen über konfigurierte Jobs und Plugins oder über Pipeline-Code abbilden. Seine zusätzlichen Delivery-Funktionen werden dann wertvoll, wenn die Prozedur außerdem von Build-Artefakten, Testberichten oder gemeinsamen Pipeline-Libraries abhängt.

Funktionsvergleich

Ein gemeinsam genutzter Automatisierungsdienst muss mehr leisten, als einen Befehl zu starten. Ingenieure bereiten die Operation und ihren Zugriff vor, Kolleginnen und Kollegen starten sie mit passenden Eingaben, und die Ausführung erreicht die verwalteten Systeme. Die folgenden Abschnitte vergleichen, wie die beiden Produkte diese Abfolge unterstützen, einschließlich der Teile einer Delivery-Pipeline, die weiterhin in Jenkins gehören können.

Installation und Einrichtung

Laufzeitumgebung, persistenter Speicher und Update-Prozess bestimmen, wie ein gemeinsam genutzter Automatisierungsdienst betrieben wird. Jenkins speichert die Controller-Daten in seinem Dateisystem, während Semaphore UI eine Datenbank nutzt.

UnterstütztTeilweise unterstütztNicht unterstützt
Installation und Einrichtung: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
Eigenständiges natives Binary Ja NeinJava-Laufzeitumgebung erforderlich
Native Pakete Ja Ja
Serverplattformen Linux, macOS, Windows, FreeBSD Linux, macOS, Windows und weitere unterstützte Java-Plattformen

Jenkins läuft aus einer ausführbaren WAR-Datei auf einer unterstützten Java-Laufzeitumgebung, aus nativen Paketen oder in einem Container. Der Controller koordiniert Jobs auf Agenten, und Agentenlabels wählen ein passendes Betriebssystem oder eine passende Toolchain aus. Bestehende Agenten und die dort installierten Werkzeuge können daher sowohl für Delivery-Pipelines als auch für Wartungsjobs weiterhin nützlich bleiben.

Semaphore UI stellt eigenständige Binaries, native Pakete sowie Docker- und Kubernetes-Deployments bereit. Eine kleine Installation kann die Automatisierung auf demselben Server ausführen wie den Webdienst. Die Binary- und Paketvarianten benötigen weder eine JVM noch einen Kubernetes-Cluster und geben einem Team damit ein konventionelles Server-Deployment, bevor es verteilte Ausführung braucht. Die Ansible-Ausführung benötigt weiterhin eine unterstützte Steuerungsumgebung, etwa Linux, WSL oder einen Linux-Runner, auch wenn der Webdienst unter Windows läuft.

Automatisierungstools

Provisionierung, die Konfiguration von Hosts und die Wartung von Diensten nutzen oft unterschiedliche Werkzeuge. Der Unterschied liegt darin, wie jede Operation vorbereitet und wiederverwendet wird, und nicht darin, ob eine Shell deren Befehl aufrufen kann.

UnterstütztTeilweise unterstütztNicht unterstützt
Automatisierungstools: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
Ansible-Playbooks JaTask Template JaAnsible-Plugin oder CLI
Terraform/OpenTofu JaTask Template JaJob-Schritt oder Pipeline
Terragrunt JaTask Template JaJob-Schritt oder Pipeline
Bash JaTask Template JaJob-Schritt oder Pipeline
PowerShell JaTask Template JaJob-Schritt oder Pipeline
Python JaTask Template JaJob-Schritt oder Pipeline
Integriertes Terraform-HTTP-Backend JaPro NeinSeparates Backend konfigurieren

Jenkins ruft Befehlszeilenwerkzeuge über Freestyle-Build-Schritte oder Pipeline-Code auf. Sein Ansible-Plugin ergänzt beide Job-Typen um Einstellungen für Playbook, Inventar und Zugangsdaten. Ein Jenkinsfile kann Kompilierung, Tests, Image-Erstellung und Infrastrukturänderungen kombinieren und hält die Abfolge gemeinsam mit der Anwendung im Review.

Semaphore UI gibt Ansible, Terraform/OpenTofu, Terragrunt, Bash, PowerShell und Python jeweils eigene Task Templates. Ingenieure wählen Repository, Werkzeugeinstellungen, Zugangsdaten und gemeinsame Variablen in der Oberfläche aus, während der Automatisierungscode in Git bleibt. Ein Terraform-Provisionierungsaufgabe oder eine Python-Bereitschaftsprüfung kann eigenständig, nach Zeitplan oder innerhalb eines Workflows laufen. Das passt zu Teams, die gemeinsame Starteinstellungen in Semaphore UI pflegen und vorbereitete Operationen über die Oberfläche verfügbar machen wollen. Ein Jenkinsfile ist nützlich, wenn Änderungen an der Orchestrierung selbst, einschließlich Job-Abfolge und Konfiguration, Code-Review und Versionshistorie benötigen.

Semaphore UI Pro enthält ein HTTP-Backend für den Terraform/OpenTofu-State, mit Workspaces, Versionshistorie und Verwaltung über die UI. Ein Team, das mehrere Umgebungen provisioniert, kann deren State-Versionen in demselben Dienst einsehen, mit dem es die Änderungen ausführt. Jenkins bietet kein integriertes HTTP-State-Backend. Sein Terraform-Plugin hält eine lokale State-Datei im Job-Workspace, während CLI-basierte Jobs ein S3-, Cloud- oder anderes Remote-Backend nutzen können, das das Team konfiguriert. Eine lokale State-Datei des Plugins ist etwas anderes als ein gemeinsam genutzter State-Dienst. Semaphore UI kann ebenfalls ein externes Backend verwenden.

Wenn eine IaC-Änderung eine Freigabe benötigt, ist das Speichern des State etwas anderes als das Bewahren genau jenes Plans, der angewendet werden soll. Die Standardabfolge von Semaphore UI für Terraform plant und wendet an, ohne automatisch einen gespeicherten Plan wiederzuverwenden, und ihre Standardbefehle deaktivieren das State-Locking, sofern nichts anderes festgelegt wird. Konfigurieren Sie diese Befehlsoptionen für einen Prozess, der eine Freigabe anhand eines gespeicherten Plans oder ein Locking benötigt. Das State-Backend und der Workflow unterstützen dann den vorgesehenen Änderungsprozess, ersetzen aber nicht dessen Konfiguration.

Gespeicherte Operationen und Zeitpläne

Ein Dienst-Neustart, eine Zertifikatserneuerung oder ein Anwendungs-Release sollte die eigene Konfiguration behalten. Kolleginnen und Kollegen wählen dann die Operation aus, geben die wechselnden Eingaben an und führen sie manuell oder nach Zeitplan aus.

UnterstütztTeilweise unterstütztNicht unterstützt
Gespeicherte Operationen und Zeitpläne: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
Eingaben beim Start Ja Ja
Gemeinsame Konfiguration JaVariablengruppen JaShared Libraries oder verwaltete Dateien
Geplante Ausführungen Ja Ja
Build-Versionen und Auswahl des Deployments JaVerknüpfte Build- und Deploy-Vorlagen JaPipeline-Stages und Build-Parameter
Gespeicherte Repository-Verbindungen JaBenannte Projekt-Repositories, die von Vorlagen wiederverwendet werden JaJob-SCM-Einstellungen oder Jenkinsfile

Jenkins-Freestyle-Jobs erfassen Parameter in der Oberfläche, während Pipelines die Abfolge im Code halten. Task Templates in Semaphore UI bringen Werkzeug, Repository, Inventar, Zugangsdaten und Variablengruppen in einer gespeicherten Operation zusammen. Ingenieure können separate Vorlagen für Backup, Deployment und Dienstwiederherstellung vorbereiten, die diese Ressourcen wiederverwenden.

Für einen Neustart kann ein Eingabeformular nach einem Dienst und dem gewünschten Zustand fragen, ohne dass der Operator die Verbindungsdetails erneut zusammenstellen muss. Benannte Variablengruppen liefern die gemeinsame Umgebungskonfiguration. Jenkins-Parameter und verwaltete Konfigurationsdateien können dieselbe Aufgabe erfüllen, wobei die Referenzen und alle erforderlichen Bindings in diesem Job oder seiner Pipeline konfiguriert werden.

Konfiguration eines Ansible-Task-Templates in Semaphore UI mit Repository, Playbook, Inventar und wiederverwendbaren Variablen.
Semaphore UI. Ein Ansible-Task-Template hält Repository, Playbook, Inventar und Variablengruppen in einer vorbereiteten Operation zusammen.
Jenkins-Pipeline-Konfigurationseditor mit einem Pipeline-Skript, der Option Groovy Sandbox und der Schaltfläche Save.
Jenkins. Eine Pipeline-Definition kann im Konfigurationsbildschirm bearbeitet oder aus einem Jenkinsfile in der Versionsverwaltung geladen werden. Offizielle Dokumentation

Semaphore UI verknüpft außerdem Build- und Deploy-Vorlagen. Ein Build hält eine aufsteigende Version fest, und ein Deployment wählt eine erfolgreiche Build-Version aus oder startet automatisch nach einem erfolgreichen Build. Die Automatisierung veröffentlicht das Paket oder Image im vom Team gewählten Speicher und ruft es von dort ab. Jenkins-Pipelines bieten denselben Release-Verlauf über Stages, Parameter und den Umgang mit Artefakten, mit umfangreicherem Test- und Delivery-Reporting.

Beide können eine nächtliche Zertifikatsprüfung ohne neuen Commit ausführen. Semaphore UI hängt einen Cron-Ausdruck oder einen einmaligen Zeitplan an die vorbereitete Vorlage. Jenkins hängt Cron-Trigger an Jobs oder Pipelines. Das gespeicherte Inventar und die gespeicherten Variablen machen wiederkehrende Host-Operationen wiederholbar, ohne jeden Start zu einer neuen Konfiguration zu machen.

Inventar

Die Host-Wartung setzt eine wiederverwendbare Definition der Ziele und ihrer Verbindungseinstellungen voraus. Ein Patch-Durchlauf, ein Backup und eine Zertifikatsprüfung können diese Definition gemeinsam nutzen.

UnterstütztTeilweise unterstütztNicht unterstützt
Inventar: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
Wiederverwendbare Ansible-Inventories JaIn der UI verwaltete Inventarressourcen JaInventardateien oder Plugin-Konfiguration
Dynamische Host-Erkennung JaAnsible-Inventarplugins JaAnsible-Inventarplugins im Job ausführen
Host-Auswahl beim Start JaEingabeaufforderung für Ansible limit Jalimit des Ansible-Plugins oder Job-Parameter

Semaphore UI macht ein Inventar zu einer benannten Projektressource, die Vorlagen gemeinsam nutzen können. Es kann bearbeitbares INI/YAML enthalten, eine Datei in Git referenzieren oder Ansibles dynamische Inventarplugins verwenden. Das ausgewählte Inventar hält außerdem die Referenzen auf Host-Zugangsdaten und optionale sudo-Zugangsdaten, sodass eine Änderung der Zielkonfiguration nicht das Bearbeiten jeder einzelnen Wartungsoperation erfordert.

Jenkins kann dieselben Ansible-Dateien und Discovery-Plugins verwenden. Sein Ansible-Plugin akzeptiert einen Inventarpfad oder Inline-Inhalte und stellt Ansible-Limit-Einstellungen bereit. Jobs und verwaltete Dateien können diese Konfiguration wiederverwenden. Beide Produkte können Hosts über Cloud-APIs oder andere Systeme ermitteln, die von den installierten Ansible-Plugins unterstützt werden. Der Unterschied bei Semaphore UI liegt im wiederverwendbaren Inventarobjekt und den Verbindungseinstellungen in der Bedienoberfläche.

Bei einer Wiederherstellungsaufgabe auf einem einzelnen Server grenzt ein zugelassenes Ansible-Limit die Ausführung ein, ohne ein neues Inventar anzulegen. Damit werden Hosts innerhalb einer Aufgabe ausgewählt, statt den gesamten Bestand automatisch auf unabhängige Jobs aufzuteilen. Ein Inventar in Git ist bei beiden Produkten sinnvoll, wenn Änderungen geprüft werden sollen.

Ausführung

Die Ausführung muss das Zielnetzwerk mit den richtigen Abhängigkeiten erreichen. Die Platzierung der Worker und die Isolierung pro Job sind unabhängig davon, wie der Webserver installiert ist.

UnterstütztTeilweise unterstütztNicht unterstützt
Ausführung: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
Fernausführung JaRunners JaAgenten
Containerisierte Jobs JaProDocker-Executor pro Task JaDocker-Pipeline-Plugin
Kubernetes-Job-Pods JaEnterprise JaKubernetes-Plugin
Runner-Routing JaProRunner-Tags JaAgentenlabels
Worker-Zuweisung JaProDem Projekt zugewiesene Runner JaVon Jobs ausgewählte Agentenlabels

Jenkins-Agenten führen Jobs auf Maschinen aus, die anhand von Labels und der Pipeline-Konfiguration ausgewählt werden. Semaphore UI kann Aufgaben lokal auf seinem Server ausführen oder an Runner in der Nähe der verwalteten Systeme senden. Ein Runner kann die Automatisierung innerhalb eines privaten Netzwerks ausführen, während die zentrale Oberfläche den Vorgang protokolliert.

Semaphore UI Pro ergänzt projektgebundene Runner und tagbasiertes Routing, sodass Produktionsvorgänge einen anderen Ausführungspool als Staging nutzen können. Jenkins-Agentenlabels legen fest, wo ein Job läuft, schränken aber selbst nicht ein, wer den Agenten nutzen darf. Builds laufen standardmäßig als SYSTEM. Um Agentenberechtigungen durchzusetzen, ist daher auch eine passende Build-Autorisierung erforderlich.

Für kurzlebige Laufzeitumgebungen führt Semaphore UI Pro einzelne Aufgaben in Docker aus, während Enterprise Kubernetes-Aufgaben-Pods unterstützt. Jenkins nutzt Docker Pipeline und Kubernetes-Plugins für entsprechende Umgebungen. Die Containerisierung des Servers allein verschafft nicht jedem Vorgang eine eigene Laufzeitumgebung. Diese Möglichkeiten sind wichtig, wenn Jobs unterschiedliche Werkzeugversionen oder Abhängigkeiten benötigen.

Workflows

Einen Host zu provisionieren, ihn zu konfigurieren und seinen Dienst zu überprüfen verbindet mehrere gespeicherte Operationen. Fehler und Freigabepunkte bestimmen, ob der nächste Schritt ausgeführt werden soll.

UnterstütztTeilweise unterstütztNicht unterstützt
Workflows: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
Graphbasierte Workflow-Bearbeitung JaGespeicherte Vorlagen visuell verbinden JaBlue Ocean-Editor, veraltet
Erfolgs- und Fehlerzweige JaVisuelle Workflow-Verbindungen JaPipeline-Bedingungen und Post-Actions
Genehmigungsschritte Ja JaPipeline Input Step
Übergeben von Workflow-Werten Ja JaPipeline-Variablen und Rückgabewerte von Schritten
Dateien zwischen Schritten TeilweiseGemeinsamen Speicher oder eine Übertragung konfigurieren Jastash und unstash innerhalb einer Pipeline
Wiederverwendbare mehrstufige Komponenten TeilweiseTasks wiederverwenden, die Abfolge neu aufbauen JaShared Libraries

Mehrere Vorgänge können zu einem Semaphore-UI-Workflow werden. Eine OpenTofu-Vorlage stellt Staging bereit, ein Genehmigungsschritt pausiert vor der nächsten Änderung, und eine Ansible-Vorlage konfiguriert die Hosts. Ein Fehlerzweig kann eine Bash-Benachrichtigung oder Wiederherstellungsprozedur starten. Jede Aufgabe behält ihre werkzeugspezifische Konfiguration und kann auch unabhängig gestartet werden. Der Graph macht die Beziehungen zwischen vorbereiteten Vorgängen sichtbar, ohne sie alle in ein einziges Pipeline-Skript umzuwandeln.

In Semaphore UI werden die Verbindungen zwischen gespeicherten Vorlagen im Workflow-Editor erstellt. Auch Jenkins bietet mit dem Blue Ocean Pipeline Editor eine visuelle Erstellung. Dieser erzeugt SCM-basierte Declarative Pipelines und speichert ein Jenkinsfile. Nicht jede Funktion von Declarative Pipeline wird abgedeckt. Blue Ocean wurde im Juli 2026 abgekündigt und erhält keine Sicherheits- oder Funktionsupdates mehr. Jenkins empfiehlt deshalb seine gepflegten Werkzeuge zur Syntaxgenerierung für die Pipeline-Erstellung.

Workflow-Werte können diese Schritte verbinden, etwa indem die Adresse eines bereitgestellten Hosts an eine Konfigurationsaufgabe übergeben wird. Semaphore UI 2.20 erfasst Ansible set_stats, Terraform/OpenTofu/Terragrunt-Ausgaben und JSON aus Bash, PowerShell oder Python mit dem lokalen Executor auf dem Server oder einem Runner. Docker- und Kubernetes-Executors für Aufgaben erzeugen diese Workflow-Ausgaben nicht. Die empfangende Vorlage deklariert die Eingabe, die ihr Playbook oder ihre Inventarkonfiguration anschließend verwendet, um den neuen Host anzusprechen.

Visueller Workflow in Semaphore UI, der vorbereitete Automatisierungsvorlagen verbindet.
Semaphore UI. Ein visueller Workflow verbindet vorbereitete Task Templates zu einem wiederholbaren Ablauf.
Jenkins Pipeline Graph View mit parallelen Zweigen, abgeschlossenen Stages und Details einer ausgewählten Stage.
Jenkins. Das Plugin Pipeline Graph View zeigt Stages, parallele Zweige und Details der ausgewählten Stage. Offizielles Beispiel

Jenkins Shared Libraries können eine gepflegte mehrstufige Prozedur für viele Pipelines bündeln. Semaphore UI verwendet einzelne Task Templates wieder. Jeder Workflow definiert die Verbindungen dazwischen und kann keinen anderen Workflow als einzelnen Knoten einbetten. Shared Libraries sind wertvoll, wenn eine Auslieferungssequenz selbst zentral versioniert werden muss. Unabhängige Vorgänge wiederzuverwenden reicht häufig aus, wenn Deployment, Diagnose und Wiederherstellung sie unterschiedlich kombinieren.

Jenkins stash, unstash und archivierte Artefakte übertragen oder speichern Dateien. Workflow-Werte in Semaphore UI transportieren Daten, während Pakete und gespeicherte Terraform-Pläne konfigurierten Speicher oder eine ausdrückliche Übertragung benötigen. Eine Build-Version bezeichnet, was abgerufen werden soll, ist aber kein Dateirepository. Diese Unterscheidung zählt, wenn spätere Schritte genau das getestete Paket oder den genehmigten Plan verwenden müssen.

Zugriffskontrolle und Anmeldung

Die Person, die eine vorbereitete Operation ausführt, muss nicht die Person sein, die sie ändert. Projektberechtigungen, engere Ausführungsrechte und Anmeldekontrollen lösen jeweils unterschiedliche Teile dieser Delegation.

UnterstütztTeilweise unterstütztNicht unterstützt
Zugriffskontrolle und Anmeldung: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
Projekt-Zugriffsregeln Ja JaAutorisierungsstrategie
Ausführen ohne Job-Administration JaTask Runner JaBuild-Berechtigung ohne Configure
Berechtigungen auf Job-Ebene JaEnterpriseVorlagenberechtigungen JaPlugin für projektbasierte Autorisierung
LDAP-Anmeldung JaPro JaLDAP-Plugin
Anmeldung über OpenID Connect JaPro JaOIDC-Plugin
Multi-Faktor-Authentifizierung JaProLokales TOTP oder Identity Provider JaÜber den konfigurierten Identity Provider

Jenkins trennt Authentifizierung und Autorisierung. Matrix- und projektbasierte Autorisierungsstrategien können unterscheiden, wer einen Job konfigurieren und wer ihn ausführen darf. Administratoren kombinieren die entsprechenden Plugins und Berechtigungen mit dem Identitätssystem ihrer Organisation.

Semaphore UI Community unterstützt die gemeinsame Ausführung bereits durch Projektrollen. Owners und Managers pflegen das Projekt, während ein Task Runner dessen Vorlagen starten darf und auf andere Projektressourcen nur lesend zugreift. So kann ein Engineering-Team seine Vorgänge teilen, ohne jedem Bediener Aufgaben der Projektadministration zu übertragen. Die Rolle umfasst die Vorlagen des Projekts und nicht nur eine ausgewählte Prozedur.

Enterprise ergänzt benutzerdefinierte Rollen und Ausführungsberechtigungen auf Vorlagenebene. Wenn Supportmitarbeiter einen bestimmten Neustart in der Produktion ausführen sollen statt jeder Vorlage im Projekt, kann ein Administrator mit einer Guest-Rolle beginnen und über eine benutzerdefinierte Rolle die Ausführung dieser Vorlage erlauben. Der Ingenieur bereitet Inventar, Zugangsdaten und Startoptionen vor. Das ermöglicht eine gezieltere Delegation innerhalb von Semaphore UI. Jenkins kann über seine Autorisierungskonfiguration eine Delegation auf Jobebene umsetzen.

Ein Startformular erfasst Eingaben. Was der Vorgang tun darf, bestimmen jedoch Automatisierung und Berechtigungen. Bei einem eng begrenzten Neustart müssen Playbook und erlaubte Überschreibungen den vorgesehenen Dienst und die Zielsysteme beibehalten. Vorlagenberechtigungen schaffen keine unabhängigen Inventar- oder Zugangsdatenberechtigungen für beliebige Kombinationen von Ressourcen.

Jenkins ergänzt LDAP und OpenID Connect über Security-Realm-Plugins. Mehrfaktorprüfungen können durch den gewählten Identitätsanbieter erzwungen werden. Semaphore UI Pro bietet lokales TOTP und unterstützt LDAP und OIDC. Die zentrale Identitätsverwaltung prüft, wer sich anmeldet. Projektrollen und Vorlagenberechtigungen bestimmen weiterhin, welche Vorgänge diese Person ausführen darf.

Secrets

Ein Operator sollte die vorbereitete Verbindung auswählen, anstatt immer wieder Passwörter in die Starteingaben einzufügen. Vorhandene Vaults können diese Verbindungen liefern, ohne zu Job-Parametern zu werden.

UnterstütztTeilweise unterstütztNicht unterstützt
Secrets: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
Gespeicherte SSH-Schlüssel und Passwörter JaKey Store JaCredentials-Store
Ansible-Vault-Passwörter JaVorlagenzugangsdaten JaAnsible-Plugin
HashiCorp Vault JaPro JaVault-Plugin
AWS Secrets Manager JaEnterprise JaCredentials Provider-Plugin
Azure Key Vault JaEnterprise JaAzure Key Vault-Plugin
Externe OpenBao-Secrets JaProKey Store-Integration JaCLI-Abruf im Job konfiguriert
Devolutions Server-Zugangsdaten JaEnterpriseKey Store-Integration JaCredential-API-Aufruf im Job konfiguriert
CyberArk-Secrets JaEnterpriseSpeicherung über die PVWA-REST-API JaConjur Secrets-Plugin

Jenkins speichert Zugangsdaten und stellt sie über Build-Step-Integrationen und Pipeline-Bindings bereit. Plugins verbinden Jobs außerdem mit Diensten wie HashiCorp Vault und AWS Secrets Manager. Das passt zu Teams, die bereits eine Zugangsdaten- und Plugin-Konfiguration für ihre Auslieferungspipelines pflegen.

Der Key Store von Semaphore UI bildet SSH-Schlüssel sowie Zugangsdaten aus Benutzername und Passwort ab, einschließlich Passwörtern oder Zugriffstokens ohne Benutzernamen. Repositories verwenden die Zugangsdaten zum Abrufen des Codes. Ein Ansible-Inventar wählt dagegen die Anmeldedaten und optionalen sudo-Zugangsdaten für seine Hosts. Eine Vorlage kann auch auf ein Ansible-Vault-Passwort verweisen. Der Bediener startet die vorbereitete Aufgabe, statt diese getrennten Verbindungsdaten in das Startformular zu kopieren.

Bestehende Systeme zur Secret-Verwaltung können die Quelle der Zugangsdaten bleiben. Semaphore UI Pro ergänzt Integrationen für HashiCorp Vault und OpenBao, Enterprise zusätzlich AWS Secrets Manager, Azure Key Vault und Devolutions Server. Jenkins bietet vergleichbare Verbindungen über ausgewählte Plugins. Vergleichen Sie den bereits eingesetzten Vault und seine Authentifizierungsmethode. Entscheiden Sie dann, ob eine pluginbasierte Konfiguration oder eine unterstützte Semaphore-UI-Integration besser passt.

Für OpenBao und Devolutions Server bietet Semaphore UI benannte Key-Store-Integrationen in Pro beziehungsweise Enterprise. Jenkins-Jobs können einen OpenBao-Wert über dessen CLI oder einen Devolutions-Credentials-Eintrag über dessen API abrufen. Das Team pflegt Authentifizierung, Abruf und Übergabe im Job, statt eine gespeicherte Key-Store-Verbindung auszuwählen. Das ist ein praktikabler Weg, wenn der bestehende Vault und der Jobcode die Prozedur bereits abdecken.

Semaphore UI Enterprise integriert CyberArk über die PVWA REST API. Jenkins bietet das Plugin Conjur Secrets für den Dienst Conjur/Secrets Manager von CyberArk. Beide nutzen unterschiedliche CyberArk-Schnittstellen. Die Integration muss deshalb zu dem CyberArk-Dienst passen, den das Team betreibt.

Logs und Audit

Nach dem Patchen oder einem Deployment benötigt das Team sowohl die Ausführungsergebnisse als auch eine Aufzeichnung darüber, wer die Operation geändert oder gestartet hat. Diese Aufzeichnungen beantworten unterschiedliche Fragen.

UnterstütztTeilweise unterstütztNicht unterstützt
Logs und Audit: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
Ausführungsverlauf und Logs Ja Ja
Darstellung der Ansible-Ergebnisse JaProIntegrierte Host-/Task-Zusammenfassung JaKonfigurierter Ansible-JUnit-Callback und Veröffentlichung von Berichten
Administrativer Audit-Verlauf JaAufzeichnung aktivieren, Administratoransicht JaAudit Trail-Plugin
SIEM Weiterleitung JaProTLS-Syslog oder Splunk HEC JaAudit Trail Syslog oder Elasticsearch

Semaphore UI speichert Aufgabenstatus, Startdetails, Repository-Revision und Ausgabe. Pro ergänzt eine integrierte Ansible-Übersicht nach Hosts und Aufgaben, mit der sich eine fehlgeschlagene Prüfung im gesamten Bestand leichter bis zu den betroffenen Hosts verfolgen lässt. Jenkins nutzt Konsolenausgabe und konfigurierte Berichte. Der Ansible-JUnit-Callback und das JUnit-Plugin können strukturierte Ergebnisse veröffentlichen, erfordern aber die Einrichtung des Callbacks und der Berichtsveröffentlichung.

Für Zugriffsprüfungen und Vorfallanalysen protokolliert Semaphore UI bei aktiviertem Audit-Logging Authentifizierung, Ressourcenänderungen und Aufgabenaktivität. Die Audit-Ansicht für Administratoren ist in jeder Edition projektübergreifend. Jenkins Audit Trail protokolliert konfigurierte Anfragen, Authentifizierungsereignisse, Build-Auslöser und die Nutzung von Zugangsdaten über ein Plugin. Konfigurieren Sie dessen Ereignismuster und Ziele für die Aktivität, die das Team benötigt.

Semaphore UI Pro ergänzt Filter, CSV- oder JSONL-Export und die Weiterleitung über TLS Syslog oder Splunk HEC. Audit Trail kann Jenkins-Ereignisse an Syslog oder Elasticsearch senden. Beide können ein Security Information and Event Management (SIEM) speisen. Ereignisse und Umfang unterscheiden sich jedoch von gewöhnlicher Jobausgabe.

Integrationen

Ein Release-Ereignis oder ein Monitoring-System kann eine vorbereitete Operation starten und ihr Ergebnis an das Team senden. Aufschlussreich ist der Vergleich, wie viel dieser Verbindung im Produkt selbst konfiguriert wird.

UnterstütztTeilweise unterstütztNicht unterstützt
Integrationen: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
Jobs per API starten und einsehen Ja Ja
Eingehende Webhook-Trigger JaRequest-Matcher und Wert-Extraktoren JaGeneric Webhook Trigger-Plugin
Chat-Benachrichtigungen JaSlack, Teams, Telegram und weitere Kanäle JaBenachrichtigungs-Plugins

Semaphore UI bietet eine authentifizierte Aufgaben-API und eingehende Integrationsendpunkte. Matcher filtern eine Anfrage, und Extractors ordnen Header oder Felder des Anfrageinhalts den Aufgabeneingaben zu. Jenkins stellt Build- und Job-APIs bereit, während Generic Webhook Trigger Extraktion und Filter für eingehende Ereignisse ergänzt. Ein Monitoring-Alarm kann so eine vorbereitete Diagnose ohne neuen Code-Commit starten.

Semaphore UI enthält Benachrichtigungskanäle für E-Mail, Slack, Microsoft Teams, Telegram, Rocket.Chat, DingTalk und Gotify. Vorlagen und Projektalarme legen fest, wohin Ergebnisse gesendet werden. Jenkins bietet entsprechende Verbindungen über Benachrichtigungsplugins wie Slack Notification. Ein Benachrichtigungslink hilft Kollegen, eine Ausführung zu prüfen, stellt selbst aber keine Genehmigung aus dem Chat heraus dar.

KI-gestützte Automatisierung

Ein Coding-Assistent kann dabei helfen, eine Operation vorzubereiten oder einen fehlgeschlagenen Durchlauf zu untersuchen, und zwar anhand dokumentierter APIs, Konfigurationsbeispiele und der relevanten Ausgabe.

UnterstütztTeilweise unterstütztNicht unterstützt
KI-gestützte Automatisierung: Jenkins und Semaphore UI
Kriterien Semaphore UI Jenkins
MCP-Zugriff JaCommunity-Connector JaMCP Server-Plugin

Beide Produkte bieten öffentliche Dokumentation und APIs, die Assistenten wie Claude Code und Codex beim Entwerfen von Konfigurationen oder Analysieren von Jobausgaben nutzen können. Ein Jenkinsfile gibt dem Assistenten eine versionierte Pipeline-Definition. Die API von Semaphore UI stellt dagegen den gespeicherten Vorgang und seine Projektressourcen bereit. Das unterstützt Einrichtung und Fehlersuche, macht generierte Änderungen aber nicht automatisch korrekt.

Jenkins bietet ein MCP-Server-Plugin für Job- und Build-Werkzeuge. Semaphore UI hat einen Community-MCP-Connector für seine API und hat offizielle MCP-Unterstützung für Pro in Version 2.21.0 angekündigt. Der Zugriff des Connectors richtet sich nach dem bereitgestellten Konto und den Zugangsdaten. Ein Assistent sollte deshalb einen zum Vorgang passenden Berechtigungsumfang erhalten.

Lizenzierung und Support

Beide Produkte bieten einen kostenlosen Open-Source-Einstieg. Zu den Kosten eines gemeinsam genutzten Automatisierungsdienstes gehören auch die umgebende Software, die Ausführungsmaschinen und die Pflege der Konfiguration. Bezahlter Support und kommerzielle Funktionen sind eigenständige Teile dieser Entscheidung.

Open-Source- und kommerzielle Optionen

Jenkins Core steht unter der MIT-Lizenz, und das Community-Projekt erhebt keine Lizenzgebühr. Plugins haben eigene Lizenzen und Maintainer. Das Team betreibt Controller, Agenten, Java-Laufzeit und ausgewählte Integrationen und kann kommerziellen Support über einen separaten Anbieter oder ein separates Angebot beziehen.

Semaphore UI Community steht ebenfalls unter der MIT-Lizenz und enthält die grundlegende Aufgabenoberfläche, Projektrollen, Zeitpläne und Workflows. Pro und Enterprise erweitern dieselbe Produktfamilie um kommerzielle Funktionen und Herstellersupport. Ein Team kann daher mit gemeinsam genutzten Ansible-Vorgängen beginnen und benötigte Kontrollen ergänzen, ohne für diese Jobs eine vollständige Plattform zur Anwendungsauslieferung einzuführen.

Kostenpflichtige Funktionen

Semaphore UI Pro umfasst hier besprochene Funktionen wie integrierten Terraform/OpenTofu-State-Speicher, Projekt-Runner und Docker-Ausführung pro Aufgabe. Enterprise ergänzt benutzerdefinierte Rollen, Vorlagenberechtigungen und Kubernetes-Aufgabenausführung. Pro enthält Herstellersupport zu Geschäftszeiten. Enterprise bietet individuelle Supportzusagen und Unterstützung bei Einführung, Konfiguration, Upgrades und Migration. Vergleichen Sie diese Leistungen mit den Bedingungen einer Jenkins-Supportvereinbarung, statt Community-Hilfe eines der beiden Produkte als Support-SLA zu betrachten.

Wartung und Verantwortung

Für ein Team, das Jenkins hauptsächlich zur Bereitstellung von Playbooks und Wartungsbefehlen nutzt, kann Semaphore UI die individuelle Jobkonfiguration durch sein Modell aus Inventaren, Zugangsdaten, Variablen und Vorlagen ersetzen. Der betriebliche Nutzen ergibt sich aus der tatsächlich ersetzten Konfiguration und den Integrationen. Wenn Jenkins hingegen die benötigten Jobs, Agenten, Berichte und Supportleistungen bereits liefert, verursacht ein zweiter Dienst zusätzliche Arbeit. Ein Ersatz ist praktikabel, wenn Semaphore UI die verwendeten Jobs und Kontrollen abdeckt. Bleiben Jenkins-spezifische Berichte, Artefaktverarbeitung oder Shared Libraries unverzichtbar, können ausgewählte Vorgänge umziehen, während diese Pipelines in Jenkins bleiben.

Semaphore UI enthält seine Ansible-Vorlagen- und Inventareinstellungen direkt im Produkt. Vault- und Containerintegrationen werden durch die jeweilige Edition bereitgestellt. Jenkins liefert entsprechende Integrationen über Plugins, deren Abhängigkeiten und Updates neben dem Controller verwaltet werden. Dadurch verändert sich die Integrationsarbeit, die das Team übernimmt. Beide benötigen weiterhin die Automatisierungswerkzeuge und Laufzeitumgebungen auf ihren Ausführungsmaschinen.

Auswahlkriterien

Richten Sie die Wahl nach der Arbeit der Kollegen und der Konfiguration, die das Team pflegen möchte. Keines der Produkte ist auf einen Auslöser oder eine Automatisierungssprache beschränkt. Ihre stärksten Anwendungsfälle ergeben sich aus dem jeweiligen Betriebsmodell.

Wann Jenkins wählen?

Wählen Sie Jenkins, wenn integrierte Testberichte, Artefaktverarbeitung und gemeinsam genutzter mehrstufiger Pipeline-Code für die Prozedur zentral sind.

  • Build-Ergebnisse und Testnachweise bestimmen den nächsten Schritt. Der Prozess kompiliert Code, führt eine Testmatrix aus, erzeugt Berichte und überträgt Artefakte zwischen Stages.
  • Viele Projekte teilen ihre Auslieferungslogik als Code. Jenkinsfiles und Shared Libraries sind bereits der Weg, auf dem das Team diese Abläufe prüft und pflegt.
  • Die bestehende Installation deckt den betrieblichen Bedarf ab. Jobs, Agenten, Plugins und Autorisierung bieten den ausführenden Personen bereits eine wirksame Oberfläche.

Wann sollte man Semaphore UI wählen?

Wählen Sie Semaphore UI, wenn die Hauptaufgabe des Dienstes darin besteht, Infrastrukturvorgänge wiederverwendbar zu machen und dem Team bereitzustellen.

  • Ansible gehört zum täglichen Betrieb. Patching, Zertifikatsprüfungen und die Wiederherstellung von Diensten verwenden Inventare, Host-Zugangsdaten und gemeinsame Umgebungskonfigurationen wieder.
  • Kollegen benötigen vorbereitete Aktionen. Ingenieure pflegen den Code und die Task Templates, während Bediener Prozeduren über Eingabeformulare oder Zeitpläne starten. Projektrollen ermöglichen diese grundlegende Trennung. Enterprise-Vorlagenberechtigungen erlauben eine engere Delegation.
  • Sie bevorzugen werkzeugspezifische Konfiguration in der Oberfläche. Bereiten Sie Vorgänge mit Ansible, Terraform/OpenTofu, Terragrunt, Bash, PowerShell und Python über eigene Vorlagen vor, mit gemeinsam genutzten Inventaren, Zugangsdaten und Variablengruppen.
  • Die Bereitstellung soll auf den Bedarf zugeschnitten bleiben. Ein Binärprogramm oder Paket kann auf einem vorhandenen Server laufen, Runner erreichen andere Netzwerke, und Pro kann das gemeinsame Terraform/OpenTofu-State-Backend bereitstellen.

Semaphore UI zusammen mit Jenkins verwenden

Ein Release kann in Jenkins mit Kompilierung, Tests und der Veröffentlichung von Artefakten beginnen. Anschließend übergibt die Pipeline einen Image-Digest oder einen versionierten Paketverweis über die authentifizierte Aufgaben-API an eine vorbereitete Deployment-Vorlage in Semaphore UI. Semaphore UI verwendet das konfigurierte Repository, Inventar und die Zugangsdaten und leitet den Vorgang an die passende Ausführungsmaschine. Die Deployment-Automatisierung ruft das Artefakt aus der vom Team verwendeten Registry oder dem Repository ab.

Die Jenkins-Integration muss die zurückgegebene Aufgaben-ID erfassen, den endgültigen Status prüfen und entscheiden, ob die Pipeline erfolgreich ist oder fehlschlägt. Eine angenommene API-Anfrage bedeutet, dass die Aufgabe eingereiht wurde, nicht dass das Deployment erfolgreich war. Der integrierte Empfänger für eingehende Webhooks ist eine weitere Auslösemöglichkeit. Abschlussmeldungen und die Erfolgs- oder Fehlerlogik der Pipeline bleiben Teil der vom Team implementierten Integration.

Nach dem Deployment kann dasselbe Betriebsteam in Semaphore UI einen Dienstneustart über ein Formular ausführen oder eine Zertifikatsprüfung im nächtlichen Zeitplan belassen. Diese Jobs verwenden die vorbereitete Infrastrukturkonfiguration ohne neuen Anwendungs-Commit. Jenkins bleibt dabei für Build- und Testnachweise zuständig.

FAQ

Können wir vorhandene Ansible- und Terraform-Automatisierung wiederverwenden?

Ja. Jenkins-Jobs und -Pipelines können diese Werkzeuge ausführen. Das Ansible-Plugin bietet Einstellungen für Playbooks, Inventare und Zugangsdaten. Semaphore UI verwendet werkzeugspezifische Vorlagen, die mit wiederverwendbaren Inventaren, Zugangsdaten, Variablengruppen und Startformularen verknüpft sind. Der vorhandene Code kann in seinem Git-Repository bleiben, während das Team den Vorgang in einem der beiden Modelle vorbereitet.

Können Kollegen Semaphore-UI-Aufgaben ohne Enterprise ausführen?

Ja. Zu den Community-Projektrollen gehört Task Runner. Diese Rolle kann Vorlagen im Projekt starten und hat auf die anderen Projektressourcen nur Lesezugriff. Enterprise ergänzt benutzerdefinierte Rollen und Berechtigungen für einzelne Vorlagen, wenn der Zugriff enger begrenzt werden muss.

Kann Wartung unabhängig von einem neuen Commit ausgeführt werden?

Ja, mit beiden Produkten. Jenkins unterstützt manuelle Builds und geplante Jobs. Semaphore UI unterstützt manuelle Starts von Task Templates, Cron-Zeitpläne und einmalige Ausführungen mit den vorbereiteten Inventaren, Zugangsdaten und Variablen.

Kann Semaphore UI eine Jenkins-Pipeline ersetzen?

Es kann Provisionierung, Deployments und Wartung abdecken, die mit seinen unterstützten Werkzeugen implementiert sind. Entscheiden Sie bewusst, welche Jenkins-spezifischen Anforderungen erhalten oder ersetzt werden sollen, darunter Berichtsplugins, Artefaktverarbeitung und Shared Libraries. Ein separater Semaphore-UI-Vorgang kann auch von einer bestehenden Pipeline aufgerufen werden.

Kann Automatisierung innerhalb eines privaten Netzwerks laufen?

Beide Produkte ermöglichen das. Jenkins verwendet Agenten, Semaphore UI führt Aufgaben auf seinem Server oder auf Runnern aus. Die Ausführungsmaschinen können in der Nähe privater Systeme stehen. Die erforderlichen Werkzeuge müssen in der jeweils gewählten Laufzeitumgebung verfügbar sein.

War dieser Artikel hilfreich?

Quellen

  1. Semaphore UI, “Semaphore UI build and deploy templates”. URL: https://semaphoreui.com/docs/user-guide/task-templates/build-deploy (abgerufen am: ).
  2. Semaphore UI, “Semaphore UI automation applications”. URL: https://semaphoreui.com/docs/user-guide/apps (abgerufen am: ).
  3. Semaphore UI, “Semaphore UI task templates”. URL: https://semaphoreui.com/docs/user-guide/task-templates (abgerufen am: ).
  4. Semaphore UI, “Semaphore UI installation methods”. URL: https://semaphoreui.com/docs/admin-guide/installation (abgerufen am: ).
  5. Semaphore UI, “Semaphore UI runners”. URL: https://semaphoreui.com/docs/admin-guide/runners (abgerufen am: ).
  6. Semaphore UI, “Semaphore UI workflow nodes and data passing”. URL: https://semaphoreui.com/docs/user-guide/workflows (abgerufen am: ).
  7. Semaphore UI, “Semaphore UI Terraform HTTP backend”. URL: https://semaphoreui.com/docs/user-guide/apps/terraform/states (abgerufen am: ).
  8. Semaphore UI, “Semaphore UI project roles and template permissions”. URL: https://semaphoreui.com/docs/user-guide/team (abgerufen am: ).
  9. Semaphore UI, “Semaphore UI Key Store”. URL: https://semaphoreui.com/docs/user-guide/key-store (abgerufen am: ).
  10. Semaphore UI, “Semaphore UI Variable Groups”. URL: https://semaphoreui.com/docs/user-guide/environment (abgerufen am: ).
  11. Semaphore UI, “Semaphore UI schedules”. URL: https://semaphoreui.com/docs/user-guide/schedules (abgerufen am: ).
  12. Semaphore UI, “Semaphore UI webhook integrations”. URL: https://semaphoreui.com/docs/user-guide/integrations (abgerufen am: ).
  13. Semaphore UI, “Semaphore UI Community, Pro and Enterprise”. URL: https://semaphoreui.com/pricing (abgerufen am: ).
  14. Semaphore UI, “Semaphore UI inventories”. URL: https://semaphoreui.com/docs/user-guide/inventory (abgerufen am: ).
  15. Semaphore UI, “Semaphore UI 2.20 candidate Terraform execution”. URL: https://github.com/semaphoreui/semaphore/blob/58a596ed20b724af67c468588edcda12d1779549/db_lib/TerraformApp.go (abgerufen am: ).
  16. Semaphore UI, “Semaphore UI 2.20 candidate runner output handling”. URL: https://github.com/semaphoreui/semaphore/blob/58a596ed20b724af67c468588edcda12d1779549/services/runners/job_pool.go (abgerufen am: ).
  17. Jenkins project, “Jenkins downloads and release lines”. URL: https://www.jenkins.io/download/ (abgerufen am: ).
  18. Jenkins project, “Installing Jenkins”. URL: https://www.jenkins.io/doc/book/installing/ (abgerufen am: ).
  19. Jenkins project, “Using a Jenkinsfile”. URL: https://www.jenkins.io/doc/book/pipeline/jenkinsfile/ (abgerufen am: ).
  20. Jenkins project, “Pipeline Nodes and Processes”. URL: https://www.jenkins.io/doc/pipeline/steps/workflow-durable-task-step/ (abgerufen am: ).
  21. Jenkins Ansible plugin contributors, “Ansible plugin”. URL: https://plugins.jenkins.io/ansible/ (abgerufen am: ).
  22. Jenkins project, “Pipeline Syntax”. URL: https://www.jenkins.io/doc/book/pipeline/syntax/ (abgerufen am: ).
  23. Jenkins project, “Extending with Shared Libraries”. URL: https://www.jenkins.io/doc/book/pipeline/shared-libraries/ (abgerufen am: ).
  24. Jenkins project, “Pipeline Input Step”. URL: https://www.jenkins.io/doc/pipeline/steps/pipeline-input-step/ (abgerufen am: ).
  25. Jenkins project, “Pipeline Basic Steps”. URL: https://www.jenkins.io/doc/pipeline/steps/workflow-basic-steps/ (abgerufen am: ).
  26. Jenkins project, “Using Jenkins agents”. URL: https://www.jenkins.io/doc/book/using/using-agents/ (abgerufen am: ).
  27. Jenkins project, “Using Docker with Pipeline”. URL: https://www.jenkins.io/doc/book/pipeline/docker/ (abgerufen am: ).
  28. Jenkins project, “Using credentials”. URL: https://www.jenkins.io/doc/book/using/using-credentials/ (abgerufen am: ).
  29. Jenkins project, “Jenkins Access Control”. URL: https://www.jenkins.io/doc/book/security/access-control/ (abgerufen am: ).
  30. Jenkins project, “Managing Plugins”. URL: https://www.jenkins.io/doc/book/managing/plugins/ (abgerufen am: ).
  31. Jenkins project, “Jenkins Project Governance and license”. URL: https://www.jenkins.io/project/governance/ (abgerufen am: ).
  32. Jenkins Matrix Authorization contributors, “Jenkins Matrix Authorization Strategy”. URL: https://plugins.jenkins.io/matrix-auth/ (abgerufen am: ).
  33. Jenkins JUnit plugin contributors, “JUnit plugin”. URL: https://plugins.jenkins.io/junit/ (abgerufen am: ).
  34. Jenkins HashiCorp Vault plugin contributors, “HashiCorp Vault plugin”. URL: https://plugins.jenkins.io/hashicorp-vault-plugin/ (abgerufen am: ).
  35. Jenkins AWS Secrets Manager plugin contributors, “AWS Secrets Manager Credentials Provider”. URL: https://plugins.jenkins.io/aws-secrets-manager-credentials-provider/ (abgerufen am: ).
  36. Jenkins project, “Getting started with Pipeline”. URL: https://www.jenkins.io/doc/book/pipeline/getting-started/ (abgerufen am: ).
  37. Stefan Spieker, Jenkins project, “Plugin of the Month – April 2026: Pipeline Graph View”. URL: https://www.jenkins.io/blog/2026/04/06/plugin-of-the-month/ (abgerufen am: ).
  38. Semaphore UI, “Semaphore UI REST API, task creation and task status”. URL: https://semaphoreui.com/api-docs (abgerufen am: ).
  39. Semaphore UI, “Tasks, execution history and Ansible summaries”. URL: https://semaphoreui.com/docs/user-guide/tasks (abgerufen am: ).
  40. Semaphore UI, “Get Started, installation methods and server platforms”. URL: https://semaphoreui.com/docs/getting-started (abgerufen am: ).
  41. Jenkins Kubernetes plugin contributors, “Kubernetes plugin, agents in job pods”. URL: https://plugins.jenkins.io/kubernetes/ (abgerufen am: ).
  42. Jenkins Config File Provider contributors, “Config File Provider, reusable managed configuration”. URL: https://plugins.jenkins.io/config-file-provider/ (abgerufen am: ).
  43. Jenkins Terraform plugin contributors, “Terraform plugin, job workspace and local state file”. URL: https://plugins.jenkins.io/terraform/ (abgerufen am: ).
  44. Ansible project, “JUnit callback, structured playbook result reports”. URL: https://docs.ansible.com/projects/ansible/latest/collections/ansible/builtin/junit_callback.html (abgerufen am: ).
  45. Semaphore UI, “Semaphore UI authentication”. URL: https://semaphoreui.com/docs/admin-guide/authentication (abgerufen am: ).
  46. Jenkins project and plugin contributors, “LDAP authentication plugin”. URL: https://plugins.jenkins.io/ldap/ (abgerufen am: ).
  47. Jenkins project and plugin contributors, “OpenID Connect Authentication plugin”. URL: https://plugins.jenkins.io/oic-auth/ (abgerufen am: ).
  48. Jenkins project and plugin contributors, “Azure Key Vault plugin”. URL: https://plugins.jenkins.io/azure-keyvault/ (abgerufen am: ).
  49. Semaphore UI, “Semaphore UI audit history, export and SIEM forwarding”. URL: https://semaphoreui.com/docs/admin-guide/audit-log (abgerufen am: ).
  50. Jenkins project and plugin contributors, “Audit Trail plugin and external log destinations”. URL: https://plugins.jenkins.io/audit-trail/ (abgerufen am: ).
  51. Semaphore UI, “Semaphore UI notification channels”. URL: https://semaphoreui.com/docs/admin-guide/notifications (abgerufen am: ).
  52. Jenkins project and plugin contributors, “Jenkins Remote Access API”. URL: https://www.jenkins.io/doc/book/using/remote-access-api/ (abgerufen am: ).
  53. Jenkins project and plugin contributors, “Generic Webhook Trigger plugin”. URL: https://plugins.jenkins.io/generic-webhook-trigger/ (abgerufen am: ).
  54. Jenkins project and plugin contributors, “Slack Notification plugin”. URL: https://plugins.jenkins.io/slack/ (abgerufen am: ).
  55. Community connector contributors, “Community MCP connector for Semaphore UI”. URL: https://github.com/cloin/semaphore-mcp (abgerufen am: ).
  56. Jenkins project and plugin contributors, “Jenkins MCP Server plugin”. URL: https://plugins.jenkins.io/mcp-server/ (abgerufen am: ).
  57. OpenBao project, “OpenBao CLI, read a secret”. URL: https://openbao.org/docs/commands/kv/get/ (abgerufen am: ).
  58. Devolutions, “Devolutions Server REST API, credential retrieval”. URL: https://docs.devolutions.net/server/web-interface/utilities/api-documentation (abgerufen am: ).
  59. Semaphore UI, “Semaphore UI CyberArk PVWA secret storage”. URL: https://semaphoreui.com/docs/user-guide/key-store/cyberark (abgerufen am: ).
  60. Jenkins Conjur plugin contributors, “Jenkins Conjur Secrets plugin”. URL: https://plugins.jenkins.io/conjur-credentials/ (abgerufen am: ).
  61. Jenkins project, “Jenkins access control for builds”. URL: https://www.jenkins.io/doc/book/security/build-authorization/ (abgerufen am: ).
  62. Jenkins project, “Blue Ocean Pipeline Editor and deprecation status”. URL: https://www.jenkins.io/doc/book/blueocean/pipeline-editor/ (abgerufen am: ).
  63. Jenkins project, “Jenkins persistent objects and filesystem storage”. URL: https://www.jenkins.io/doc/developer/persistence/ (abgerufen am: ).

Vergleich des Semaphore UI Teams auf Grundlage der oben aufgeführten Dokumentation, Repositories und Produktinformationen. Das Abrufdatum ist für jede Quelle angegeben.