Konfiguration

Semaphore kann auf mehrere Arten konfiguriert werden:

Online-Konfigurator — Weboberfläche zum Erzeugen der Konfiguration online.
Konfigurationsdatei — die primäre und flexibelste Methode, Semaphore zu konfigurieren.
Umgebungsvariablen — nützlich für containerisierte oder Cloud-native Bereitstellungen.

Konfigurationsoptionen

Vollständige Liste der verfügbaren Konfigurationsoptionen:

Option in der Konfigurationsdatei / Umgebungsvariable	Beschreibung
Allgemein
`git_client` `SEMAPHORE_GIT_CLIENT`	Typ des Git-Clients. Kann `cmd_git` (Standard) oder `go_git` sein.
`git_attempts` `SEMAPHORE_GIT_ATTEMPTS`	Wie oft ein git clone oder pull versucht wird, bevor die Aufgabe fehlschlägt. Verwendet exponentielles Backoff (1s, dann 2s, 4s, … bis zu 60s) zwischen den Versuchen. Standard: `4`. Auf `1` setzen, um Wiederholungen zu deaktivieren.
`ssh_config_path` `SEMAPHORE_SSH_PATH`	Pfad zu einer benutzerdefinierten SSH-Konfigurationsdatei. Standard: `~/.ssh/config`.
`port` `SEMAPHORE_PORT`	TCP-Port, unter dem die Weboberfläche erreichbar ist. Standard: `:3000`
`interface` `SEMAPHORE_INTERFACE`	Bind-Adresse (leer = alle Schnittstellen). Nützlich, wenn Ihr Server mehrere Netzwerkschnittstellen hat.
`tmp_path` `SEMAPHORE_TMP_PATH`	Pfad zum Verzeichnis, in dem geklonte Repositories und generierte Dateien gespeichert werden. Standard: /tmp/semaphore
`dirs.secrets` `SEMAPHORE_SECRETS_PATH`	Pfad zum Verzeichnis, in dem Secrets gespeichert werden (zum Beispiel Vault-Token-Dateien). Standard: `/tmp/semaphore`. Das veraltete Top-Level-Feld `secrets_path` wird weiterhin akzeptiert, wenn `dirs.secrets` nicht gesetzt ist oder auf dem Standardwert bleibt.
`dirs.repos` `SEMAPHORE_REPOS_DIR`	Pfad zum Verzeichnis, in dem Repositories gespeichert werden.
`dirs.ssh_agent_sockets` `SEMAPHORE_SSH_AGENT_SOCKETS_DIR`	Pfad zum Verzeichnis, in dem SSH-Agent-Sockets gespeichert werden. Standard: /tmp/semaphore
`home_dir_mode` `SEMAPHORE_HOME_DIR_MODE`	Steuert, wie die Umgebungsvariable HOME für Aufgaben gesetzt wird. Optionen: `template_dir` (Standard), `project_home`, `user_home`.
`max_parallel_tasks` `SEMAPHORE_MAX_PARALLEL_TASKS`	Maximale Anzahl paralleler Aufgaben, die auf dem Server ausgeführt werden können. Standard: 9999
`max_task_duration_sec` `SEMAPHORE_MAX_TASK_DURATION_SEC`	Maximale Dauer einer Aufgabe in Sekunden.
`max_tasks_per_template` `SEMAPHORE_MAX_TASKS_PER_TEMPLATE`	Maximale Anzahl der letzten Aufgaben, die pro Vorlage in der Datenbank gespeichert werden.
`schedule.timezone` `SEMAPHORE_SCHEDULE_TIMEZONE`	Zeitzone, die für die Planung von Aufgaben und Cron-Jobs verwendet wird. Standard: UTC
`oidc_providers` `SEMAPHORE_OIDC_PROVIDERS`	Einstellungen für OpenID-Provider. Sie können mehrere OpenID-Provider angeben. Mehr zur OpenID-Konfiguration finden Sie unter OpenID.
`password_login_disable` `SEMAPHORE_PASSWORD_LOGIN_DISABLED`	Anmeldung per Passwort verweigern.
`non_admin_can_create_project` `SEMAPHORE_NON_ADMIN_CAN_CREATE_PROJECT`	Nicht-Administratoren erlauben, Projekte zu erstellen.
`env_vars` `SEMAPHORE_ENV_VARS`	JSON-Map mit Umgebungsvariablen, die Aufgabenausführungen zur Verfügung gestellt werden.
`forwarded_env_vars` `SEMAPHORE_FORWARDED_ENV_VARS`	JSON-Array von Host-Umgebungsvariablen, die an Aufgabenausführungen weitergereicht werden.
`apps` `SEMAPHORE_APPS`	JSON-Map mit der Konfiguration der Apps.
`use_remote_runner` `SEMAPHORE_USE_REMOTE_RUNNER`	Aktivieren, um einen Remote-Runner zu verwenden.
`runner_registration_token` `SEMAPHORE_RUNNER_REGISTRATION_TOKEN`	Bootstrap-Token, mit dem sich Runner beim Server registrieren.
Abonnement
`subscription.key` `SEMAPHORE_SUBSCRIPTION_KEY`	Abonnementschlüssel oder -Token. Deaktiviert die Aktivierung über die Weboberfläche, wenn gesetzt.
`subscription.key_file` `SEMAPHORE_SUBSCRIPTION_KEY_FILE`	Pfad zur Datei mit dem Abonnementschlüssel oder -Token.
`subscription.server_url` `SEMAPHORE_SUBSCRIPTION_SERVER_URL`	URL des Abonnement-/Abrechnungsservers. Standard: https://portal.semaphoreui.com/billing
JWT
`jwt.enabled` `SEMAPHORE_JWT_ENABLED`	Wenn aktiviert, erzeugt Semaphore für jede Aufgabenausführung ein kurzlebiges JWT und stellt dessen öffentlichen Schlüssel unter `/.well-known/jwks.json` bereit.
`jwt.issuer` `SEMAPHORE_JWT_ISSUER`	Wert, der im `iss`-Claim der ausgestellten JWTs ausgegeben wird.
`jwt.default_ttl` `SEMAPHORE_JWT_DEFAULT_TTL`	Standardlebensdauer eines ausgestellten Aufgaben-JWT als Go-Duration (z. B. `30m`, `1h`). Standard: 1h
`jwt.max_ttl` `SEMAPHORE_JWT_MAX_TTL`	Harte Obergrenze für die JWT-TTL pro Vorlage als Go-Duration. Standard: 24h
Runner
`runner.registration_token_file` `SEMAPHORE_RUNNER_REGISTRATION_TOKEN_FILE`	Pfad zur Datei mit dem Registrierungstoken des Runners.
`runner.token` `SEMAPHORE_RUNNER_TOKEN`	Authentifizierungstoken des Runners. Schließt sich mit `runner.token_file` gegenseitig aus.
`runner.token_file` `SEMAPHORE_RUNNER_TOKEN_FILE`	Pfad zur Token-Datei für die Runner-Registrierung.
`runner.private_key_file` `SEMAPHORE_RUNNER_PRIVATE_KEY_FILE`	Pfad zur Datei mit dem privaten Schlüssel des Runners.
`runner.one_off` `SEMAPHORE_RUNNER_ONE_OFF`	Der Runner verarbeitet einen einzelnen Job und beendet sich anschließend. Nützlich für dynamische Runner.
`runner.enabled` `SEMAPHORE_RUNNER_ENABLED`	Runner aktivieren.
`runner.webhook` `SEMAPHORE_RUNNER_WEBHOOK`	Webhook-URL für den Runner.
`runner.name` `SEMAPHORE_RUNNER_NAME`	Name des Runners.
`runner.tags` `SEMAPHORE_RUNNER_TAGS`	JSON-Array mit Runner-Tags.
`runner.max_parallel_tasks` `SEMAPHORE_RUNNER_MAX_PARALLEL_TASKS`	Maximale Anzahl paralleler Aufgaben für den Runner. Standard: 9999.
`runner.check_interval_seconds` `SEMAPHORE_RUNNER_CHECK_INTERVAL_SECONDS`	Wie oft der Runner den Server nach neuen Jobs abfragt und den Fortschritt meldet, in Sekunden. Standard: 1. Höhere Werte reduzieren das Anfragevolumen auf Kosten einer etwas langsameren Job-Übernahme.
`runner.project_id` `SEMAPHORE_RUNNER_PROJECT_ID`	Beschränkt den Runner auf ein einzelnes Projekt.
`runner.connection.server_ca_cert_file` `SEMAPHORE_RUNNER_SERVER_CA_CERT_FILE`	PEM-Bundle, das zusätzlich zum System-Truststore zur Überprüfung des Zertifikats des Semaphore-Servers verwendet wird. Setzen, wenn der Server ein selbstsigniertes Zertifikat oder ein Zertifikat einer internen CA verwendet.
`runner.connection.skip_tls_verify` `SEMAPHORE_RUNNER_SKIP_TLS_VERIFY`	Überprüfung des Serverzertifikats vollständig deaktivieren. Unsicher (anfällig für MITM) — nur zu Testzwecken verwenden.
`runner.executor` `SEMAPHORE_RUNNER_EXECUTOR`	JSON-Objekt mit der vollständigen Executor-Konfiguration des Runners (`type` plus verschachtelte `docker`- oder `k8s`-Einstellungen). Verwenden, wenn Sie den gesamten Executor-Block über eine einzige Umgebungsvariable setzen möchten.
`runner.executor.type` —	Strategie, mit der der Runner jede Aufgabe ausführt: `local` (Standard), `k8s` oder `docker`.
`runner.executor.k8s.kubeconfig` `SEMAPHORE_RUNNER_K8S_KUBECONFIG`	Pfad zu einer kubeconfig-Datei. Leer = In-Cluster-Konfiguration.
`runner.executor.k8s.namespace` `SEMAPHORE_RUNNER_K8S_NAMESPACE`	Namespace, in dem die kurzlebigen Aufgaben-Pods erstellt werden. Standard: semaphore
`runner.executor.k8s.image` `SEMAPHORE_RUNNER_K8S_IMAGE`	Standard-Container-Image für den Build-Container. Standard: semaphoreui/job:latest
`runner.executor.k8s.helper_image` `SEMAPHORE_RUNNER_K8S_HELPER_IMAGE`	Image, das für den git-clone-Init-Container verwendet wird. Standard: semaphoreui/helper:latest
`runner.executor.k8s.service_account` `SEMAPHORE_RUNNER_K8S_SERVICE_ACCOUNT`	Service Account, unter dem die Aufgaben-Pods laufen. Standard: default
`runner.executor.k8s.pull_secrets` `SEMAPHORE_RUNNER_K8S_PULL_SECRETS`	Kommagetrennte Liste von imagePullSecrets, die jedem Pod zugewiesen werden.
`runner.executor.k8s.poll_interval_seconds` `SEMAPHORE_RUNNER_K8S_POLL_INTERVAL_SECONDS`	Wie oft der Executor den Pod-Status abfragt, in Sekunden. Standard: 3
`runner.executor.k8s.cleanup_grace_seconds` `SEMAPHORE_RUNNER_K8S_CLEANUP_GRACE_SECONDS`	Karenzzeit beim Löschen von Pods, in Sekunden. Standard: 30
`runner.executor.docker.host` `SEMAPHORE_RUNNER_DOCKER_HOST`	URL des Docker-Daemons (`unix://`, `tcp://` oder `npipe://`). Leer = Standardumgebung (`DOCKER_HOST`) und plattformspezifischer Standard-Socket.
`runner.executor.docker.tls_verify` `SEMAPHORE_RUNNER_DOCKER_TLS_VERIFY`	TLS-Zertifikatsprüfung für `tcp://`-Verbindungen aktivieren.
`runner.executor.docker.cert_path` `SEMAPHORE_RUNNER_DOCKER_CERT_PATH`	Verzeichnis mit ca.pem, cert.pem und key.pem für gegenseitiges TLS.
`runner.executor.docker.image` `SEMAPHORE_RUNNER_DOCKER_IMAGE`	Standard-Image für den Build-Container. Standard: semaphoreui/job:latest
`runner.executor.docker.helper_image` `SEMAPHORE_RUNNER_DOCKER_HELPER_IMAGE`	Image, das für den temporären git-clone-Container verwendet wird. Standard: semaphoreui/helper:latest
`runner.executor.docker.network` `SEMAPHORE_RUNNER_DOCKER_NETWORK`	Docker-Netzwerk, dem der Build-Container beitritt. Standard: bridge
`runner.executor.docker.pull_policy` `SEMAPHORE_RUNNER_DOCKER_PULL_POLICY`	Pull-Richtlinie für Images: `always`, `if-not-present` (Standard) oder `never`.
`runner.executor.docker.cpu_limit` `SEMAPHORE_RUNNER_DOCKER_CPU_LIMIT`	Wenn > 0, begrenzt die CPU des Build-Containers (wird als `--cpus` übergeben).
`runner.executor.docker.memory_limit` `SEMAPHORE_RUNNER_DOCKER_MEMORY_LIMIT`	Wenn nicht leer, begrenzt den Arbeitsspeicher des Build-Containers (z. B. `2g`).
`runner.executor.docker.poll_interval_seconds` `SEMAPHORE_RUNNER_DOCKER_POLL_INTERVAL_SECONDS`	Wie oft der Container-Status abgefragt wird, in Sekunden. Standard: 2
`runner.executor.docker.cleanup_grace_seconds` `SEMAPHORE_RUNNER_DOCKER_CLEANUP_GRACE_SECONDS`	Timeout, das an `docker stop` übergeben wird, in Sekunden. Standard: 30
`runner.executor.docker.privileged` `SEMAPHORE_RUNNER_DOCKER_PRIVILEGED`	Build-Container mit `--privileged` ausführen. Gefährlich; standardmäßig deaktiviert.
Runner (serverseitige Flotte)
`runners.offline_timeout_sec` `SEMAPHORE_RUNNERS_OFFLINE_TIMEOUT_SEC`	Heartbeat-Alter (Sekunden), ab dem ein Runner als offline gilt. Seine Aufgaben im Status „starting“ werden neu zugewiesen. Standard: 120
`runners.task_fail_timeout_sec` `SEMAPHORE_RUNNERS_TASK_FAIL_TIMEOUT_SEC`	Heartbeat-Alter (Sekunden), ab dem die Aufgaben eines Runners im Status „running“ als fehlgeschlagen markiert werden. Werte unterhalb von `offline_timeout_sec` werden auf diesen Wert angehoben. Standard: 420
`runners.reconcile_interval_sec` `SEMAPHORE_RUNNERS_RECONCILE_INTERVAL_SEC`	Wie oft (Sekunden) verteilte Aufgaben mit der Erreichbarkeit der Runner abgeglichen werden. Standard: 30
Teams
`teams.invites_enabled` `SEMAPHORE_TEAMS_INVITES_ENABLED`	Benutzern erlauben, Mitglieder in Teams einzuladen.
`teams.invite_type` `SEMAPHORE_TEAMS_INVITE_TYPE`	Art der Einladung: `username` (Standard), `email`, `both`.
`teams.members_can_leave` `SEMAPHORE_TEAMS_MEMBERS_CAN_LEAVE`	Mitgliedern erlauben, Teams zu verlassen.
Datenbank
`sqlite.host` `SEMAPHORE_DB_HOST`	Pfad zur SQLite-Datenbankdatei.
`mysql.host` `SEMAPHORE_DB_HOST`	Host der MySQL-Datenbank.
`mysql.name` `SEMAPHORE_DB_NAME`	Name der MySQL-Datenbank (Schema).
`mysql.user` `SEMAPHORE_DB_USER`	MySQL-Benutzername.
`mysql.pass` `SEMAPHORE_DB_PASS`	Passwort des MySQL-Benutzers.
`postgres.host` `SEMAPHORE_DB_HOST`	Host der Postgres-Datenbank.
`postgres.name` `SEMAPHORE_DB_NAME`	Name der Postgres-Datenbank (Schema).
`postgres.user` `SEMAPHORE_DB_USER`	Postgres-Benutzername.
`postgres.pass` `SEMAPHORE_DB_PASS`	Passwort des Postgres-Benutzers.
`dialect` `SEMAPHORE_DB_DIALECT`	Kann `sqlite` (Standard), `postgres` oder `mysql` sein.
`*.options` `SEMAPHORE_DB_OPTIONS`	JSON-Map mit Optionen für die Datenbankverbindung.
Sicherheit
`access_key_encryption` `SEMAPHORE_ACCESS_KEY_ENCRYPTION`	Base64-kodierter Schlüssel zur Verschlüsselung der in der Datenbank gespeicherten Zugriffsschlüssel. Mehr dazu in der Referenz zur Datenbankverschlüsselung.
`option_encryption` `SEMAPHORE_OPTION_ENCRYPTION`	Base64-kodierter Schlüssel zur Verschlüsselung der DB-Optionen (des JWT-Signaturschlüssels) nach dem alten Einzelschlüssel-Schema (ohne Rotation). Fällt auf den Zugriffsschlüssel zurück, wenn nicht gesetzt.
`cookie_hash` `SEMAPHORE_COOKIE_HASH`	Base64-kodierter HMAC-Schlüssel zum Signieren von Cookies.
`cookie_encryption` `SEMAPHORE_COOKIE_ENCRYPTION`	Base64-kodierter Schlüssel zur Verschlüsselung von Cookies.
`web_host` `SEMAPHORE_WEB_ROOT`	Kann nützlich sein, wenn Sie Semaphore unter einem Unterpfad verwenden möchten, zum Beispiel: http://yourdomain.com/semaphore. Fügen Sie keinen abschließenden `/` hinzu.
`tls.enabled` `SEMAPHORE_TLS_ENABLED`	TLS (HTTPS) für die sichere Kommunikation mit dem Semaphore-Server aktivieren oder deaktivieren.
`tls.cert_file` `SEMAPHORE_TLS_CERT_FILE`	Pfad zur TLS-Zertifikatsdatei.
`tls.key_file` `SEMAPHORE_TLS_KEY_FILE`	Pfad zur TLS-Schlüsseldatei.
`tls.http_redirect_addr` `SEMAPHORE_TLS_HTTP_REDIRECT_ADDR`	Adresse (`host[:port]`) für den HTTP→HTTPS-Weiterleitungs-Listener. Schließt sich mit `tls.http_redirect_port` gegenseitig aus.
`tls.http_redirect_port` `SEMAPHORE_TLS_HTTP_REDIRECT_PORT`	Port, über den HTTP-Verkehr auf HTTPS umgeleitet wird. Schließt sich mit `tls.http_redirect_addr` gegenseitig aus.
`mfa.totp.enabled` `SEMAPHORE_TOTP_ENABLED`	Zwei-Faktor-Authentifizierung mit TOTP aktivieren.
`mfa.totp.app_name` `SEMAPHORE_TOTP_ISSUER`	Aussteller-Bezeichnung (Semaphore-Titel), die in TOTP-Authenticator-Apps angezeigt wird.
`mfa.totp.allow_recovery` `SEMAPHORE_TOTP_ALLOW_RECOVERY`	Benutzern erlauben, TOTP mit einem Wiederherstellungscode zurückzusetzen.
`mfa.email.enabled` `SEMAPHORE_EMAIL_2TP_ENABLED`	E-Mail-basierte Multi-Faktor-Authentifizierung aktivieren.
`mfa.email.allow_login_as_external_user` `SEMAPHORE_EMAIL_2TP_ALLOW_LOGIN_AS_EXTERNAL_USER`	Anmeldung als externer Benutzer (nur E-Mail) erlauben.
`mfa.email.allow_create_external_user` `SEMAPHORE_EMAIL_2TP_ALLOW_CREATE_EXTERNAL_USER`	Erstellen externer Benutzer bei der ersten Anmeldung erlauben.
`mfa.email.allowed_domains` `SEMAPHORE_EMAIL_2TP_ALLOWED_DOMAINS`	JSON-Array der erlaubten E-Mail-Domains.
`mfa.email.disable_for_oidc` `SEMAPHORE_EMAIL_2TP_DISABLE_FOR_OIDC`	E-Mail-MFA für Benutzer deaktivieren, die über OIDC authentifiziert sind.
Verschlüsselung
`encryption.keys_file` `SEMAPHORE_ENCRYPTION_KEYS_FILE`	Pfad zu einer separaten Datei mit den Verschlüsselungs-Keyrings (YAML oder JSON). Wird auf Änderungen überwacht — Bearbeitungen werden ohne Neustart des Servers übernommen. Wenn nicht gesetzt, wird das veraltete Feld `access_key_encryption` verwendet.
`encryption.keys_poll_interval` `SEMAPHORE_ENCRYPTION_KEYS_POLL_INTERVAL`	Wie oft `keys_file` auf Änderungen geprüft wird (eine Go-Duration wie `15s`). `0` deaktiviert die Abfrage (ein SIGHUP erzwingt weiterhin ein Neuladen). Standard: 15s
Prozess
`process.user` `SEMAPHORE_PROCESS_USER`	Benutzer, unter dem gekapselte Prozesse (wie Ansible, Terraform oder OpenTofu) ausgeführt werden.
`process.uid` `SEMAPHORE_PROCESS_UID`	ID des Benutzers, unter dem gekapselte Prozesse (wie Ansible, Terraform oder OpenTofu) ausgeführt werden.
`process.gid` `SEMAPHORE_PROCESS_GID`	ID der Gruppe, unter der gekapselte Prozesse (wie Ansible, Terraform oder OpenTofu) ausgeführt werden.
`process.chroot` `SEMAPHORE_PROCESS_CHROOT`	Chroot-Verzeichnis für gekapselte Prozesse.
`process.no_new_privs` `SEMAPHORE_PROCESS_NO_NEW_PRIVS`	Setzt das Flag `no_new_privs`, damit gekapselte Prozesse keine neuen Berechtigungen erlangen können.
`process.app_namespaces.user` `SEMAPHORE_PROCESS_APP_NS_USER`	UIDs/GIDs für App-Ausführungen isolieren (`CLONE_NEWUSER`). Nur Linux.
`process.app_namespaces.mount` `SEMAPHORE_PROCESS_APP_NS_MOUNT`	Host-Mountpunkte wie Secret-tmpfs vor App-Ausführungen verbergen (`CLONE_NEWNS`). Nur Linux.
`process.app_namespaces.pid` `SEMAPHORE_PROCESS_APP_NS_PID`	Host-Prozesse vor App-Ausführungen verbergen (`CLONE_NEWPID`). Nur Linux.
`process.app_namespaces.ipc` `SEMAPHORE_PROCESS_APP_NS_IPC`	SysV-IPC und POSIX-Message-Queues für App-Ausführungen isolieren (`CLONE_NEWIPC`). Nur Linux.
`process.app_namespaces.uts` `SEMAPHORE_PROCESS_APP_NS_UTS`	Hostname und Domain für App-Ausführungen isolieren (`CLONE_NEWUTS`). Nur Linux.
E-Mail
`email_sender` `SEMAPHORE_EMAIL_SENDER`	E-Mail-Adresse des Absenders.
`email_host` `SEMAPHORE_EMAIL_HOST`	Hostname des SMTP-Servers.
`email_port` `SEMAPHORE_EMAIL_PORT`	Port des SMTP-Servers.
`email_secure` `SEMAPHORE_EMAIL_SECURE`	StartTLS aktivieren, um eine unverschlüsselte SMTP-Verbindung auf eine sichere, verschlüsselte Verbindung hochzustufen.
`email_tls` `SEMAPHORE_EMAIL_TLS`	SSL- oder TLS-Verbindung für die Kommunikation mit dem SMTP-Server verwenden.
`email_tls_min_version` `SEMAPHORE_EMAIL_TLS_MIN_VERSION`	Minimale TLS-Version, die für die Verbindung verwendet wird.
`email_username` `SEMAPHORE_EMAIL_USERNAME`	Benutzername für die Authentifizierung am SMTP-Server.
`email_password` `SEMAPHORE_EMAIL_PASSWORD`	Passwort für die Authentifizierung am SMTP-Server.
`email_alert` `SEMAPHORE_EMAIL_ALERT`	Flag, das E-Mail-Benachrichtigungen aktiviert.
Messenger
`telegram_alert` `SEMAPHORE_TELEGRAM_ALERT`	Auf True setzen, um Benachrichtigungen an Telegram zu senden. Sollte in Kombination mit `telegram_chat` und `telegram_token` verwendet werden.
`telegram_chat` `SEMAPHORE_TELEGRAM_CHAT`	Auf die Chat-ID des Chats setzen, an den Benachrichtigungen gesendet werden sollen. Mehr dazu unter Einrichtung von Telegram-Benachrichtigungen
`telegram_token` `SEMAPHORE_TELEGRAM_TOKEN`	Auf das Autorisierungstoken des Bots setzen, der die Benachrichtigungsdaten empfängt. Mehr dazu unter Einrichtung von Telegram-Benachrichtigungen
`slack_alert` `SEMAPHORE_SLACK_ALERT`	Auf True setzen, um Benachrichtigungen an Slack zu senden. Sollte in Kombination mit `slack_url` verwendet werden
`slack_url` `SEMAPHORE_SLACK_URL`	Die Slack-Webhook-URL. Semaphore sendet damit per POST Slack-formatierte JSON-Benachrichtigungen an die angegebene URL.
`microsoft_teams_alert` `SEMAPHORE_MICROSOFT_TEAMS_ALERT`	Flag, das Microsoft-Teams-Benachrichtigungen aktiviert.
`microsoft_teams_url` `SEMAPHORE_MICROSOFT_TEAMS_URL`	Microsoft-Teams-Webhook-URL.
`rocketchat_alert` `SEMAPHORE_ROCKETCHAT_ALERT`	Auf True setzen, um Benachrichtigungen an Rocket.Chat zu senden. Sollte in Kombination mit `rocketchat_url` verwendet werden. Verfügbar seit v2.9.56.
`rocketchat_url` `SEMAPHORE_ROCKETCHAT_URL`	Die Rocket.Chat-Webhook-URL. Semaphore sendet damit per POST Rocket.Chat-formatierte JSON-Benachrichtigungen an die angegebene URL. Verfügbar seit v2.9.56.
`dingtalk_alert` `SEMAPHORE_DINGTALK_ALERT`	Dingtalk-Benachrichtigungen aktivieren.
`dingtalk_url` `SEMAPHORE_DINGTALK_URL`	Webhook-URL des Dingtalk-Messengers.
`gotify_alert` `SEMAPHORE_GOTIFY_ALERT`	Gotify-Benachrichtigungen aktivieren.
`gotify_url` `SEMAPHORE_GOTIFY_URL`	URL des Gotify-Servers.
`gotify_token` `SEMAPHORE_GOTIFY_TOKEN`	Token des Gotify-Servers.
LDAP
`ldap_enable` `SEMAPHORE_LDAP_ENABLE`	Flag, das die LDAP-Authentifizierung aktiviert.
`ldap_needtls` `SEMAPHORE_LDAP_NEEDTLS`	Flag zum Aktivieren oder Deaktivieren von TLS für LDAP-Verbindungen.
`ldap_binddn` `SEMAPHORE_LDAP_BIND_DN`	Der Distinguished Name (DN), der für das Bind am LDAP-Server zur Authentifizierung verwendet wird.
`ldap_bindpassword` `SEMAPHORE_LDAP_BIND_PASSWORD`	Das Passwort, das für das Bind am LDAP-Server zur Authentifizierung verwendet wird.
`ldap_server` `SEMAPHORE_LDAP_SERVER`	Hostname und Port des LDAP-Servers (z. B. ldap-server.com:1389).
`ldap_searchdn` `SEMAPHORE_LDAP_SEARCH_DN`	Der Basis-Distinguished-Name (DN), der für die Suche nach Benutzern im LDAP-Verzeichnis verwendet wird (z. B. dc=example,dc=org).
`ldap_searchfilter` `SEMAPHORE_LDAP_SEARCH_FILTER`	Der Filter, der für die Suche nach Benutzern im LDAP-Verzeichnis verwendet wird (z. B. (&(objectClass=inetOrgPerson)(uid=%s))).
`ldap_mappings.dn` `SEMAPHORE_LDAP_MAPPING_DN`	LDAP-Attribut, das als Zuordnung für den Distinguished Name (DN) bei der Benutzerauthentifizierung verwendet wird.
`ldap_mappings.mail` `SEMAPHORE_LDAP_MAPPING_MAIL`	LDAP-Attribut, das als Zuordnung für die E-Mail-Adresse bei der Benutzerauthentifizierung verwendet wird.
`ldap_mappings.uid` `SEMAPHORE_LDAP_MAPPING_UID`	LDAP-Attribut, das als Zuordnung für die Benutzer-ID (UID) bei der Benutzerauthentifizierung verwendet wird.
`ldap_mappings.cn` `SEMAPHORE_LDAP_MAPPING_CN`	LDAP-Attribut, das als Zuordnung für den Common Name (CN) bei der Benutzerauthentifizierung verwendet wird.
Protokollierung
`log.events.format` `SEMAPHORE_EVENT_LOG_FORMAT`	Format des Ereignisprotokolls. Kann `json` oder leer für Text sein.
`log.events.enabled` `SEMAPHORE_EVENT_LOG_ENABLED`	Ereignisprotokollierung aktivieren oder deaktivieren.
`log.events.logger` `SEMAPHORE_EVENT_LOGGER`	JSON-Map mit der Konfiguration des Ereignis-Loggers.
`log.tasks.format` `SEMAPHORE_TASK_LOG_FORMAT`	Format des Aufgabenprotokolls. Kann `json` oder leer für Text sein.
`log.tasks.enabled` `SEMAPHORE_TASK_LOG_ENABLED`	Aufgabenprotokollierung aktivieren oder deaktivieren.
`log.tasks.logger` `SEMAPHORE_TASK_LOGGER`	JSON-Map mit der Konfiguration des Aufgaben-Loggers.
`log.tasks.result_logger` `SEMAPHORE_TASK_RESULT_LOGGER`	JSON-Map mit der Konfiguration des Loggers für Aufgabenergebnisse.
`syslog.enabled` `SEMAPHORE_SYSLOG_ENABLED`	Schreiben von Protokollen an den konfigurierten Syslog-Server aktivieren oder deaktivieren.
`syslog.network` `SEMAPHORE_SYSLOG_NETWORK`	Protokoll für die Verbindung zum Syslog-Server: `udp` oder `tcp`.
`syslog.address` `SEMAPHORE_SYSLOG_ADDRESS`	Hostname und Port des Syslog-Servers. Beispiel: `localhost:514`.
`syslog.tag` `SEMAPHORE_SYSLOG_TAG`	Das Tag, mit dem Semaphore-UI-Einträge auf dem Syslog-Server gekennzeichnet werden.
`syslog.format` `SEMAPHORE_SYSLOG_FORMAT`	Format der Syslog-Nachrichten. Kann `rfc5424` oder leer für den Standard sein.
Debugging
`debugging.api_delay` `SEMAPHORE_API_DELAY`	Verzögerung zu API-Antworten hinzufügen (zu Debugging-Zwecken).
`debugging.pprof_dump_dir` `SEMAPHORE_PPROF_DUMP_DIR`	Verzeichnis für pprof-Dump-Dateien.
Hochverfügbarkeit (HA)
`ha.enabled` `SEMAPHORE_HA_ENABLED`	Hochverfügbarkeitsmodus (HA) aktivieren.
`ha.node_id` `SEMAPHORE_HA_NODE_ID`	Eindeutige Kennung des HA-Knotens.
`ha.redis.addr` `SEMAPHORE_HA_REDIS_ADDR`	Adresse des für HA verwendeten Redis-Servers. Beispiel: `localhost:6379`.
`ha.redis.db` `SEMAPHORE_HA_REDIS_DB`	Nummer der Redis-Datenbank.
`ha.redis.pass` `SEMAPHORE_HA_REDIS_PASS`	Passwort für den Redis-Server.
`ha.redis.user` `SEMAPHORE_HA_REDIS_USER`	Benutzername für den Redis-Server.
`ha.redis.tls` `SEMAPHORE_HA_REDIS_TLS`	TLS für die Redis-Verbindung aktivieren.
`ha.redis.tls_skip_verify` `SEMAPHORE_HA_REDIS_TLS_SKIP_VERIFY`	TLS-Zertifikatsprüfung für die Redis-Verbindung überspringen.