Configuration

Semaphore peut être configuré de plusieurs manières :

Configurateur en ligne — interface web pour générer la configuration en ligne.
Fichier de configuration — le moyen principal et le plus flexible de configurer Semaphore.
Variables d'environnement — utiles pour les déploiements conteneurisés ou cloud-native.

Options de configuration

Liste complète des options de configuration disponibles :

Option du fichier de configuration / Variable d'environnement	Description
Général
`git_client` `SEMAPHORE_GIT_CLIENT`	Type de client Git. Peut être `cmd_git` (par défaut) ou `go_git`.
`git_attempts` `SEMAPHORE_GIT_ATTEMPTS`	Nombre de tentatives de git clone ou pull avant que la tâche n'échoue. Utilise un backoff exponentiel (1 s, puis 2 s, 4 s, … jusqu'à 60 s) entre les tentatives. Par défaut : `4`. Définissez `1` pour désactiver les nouvelles tentatives.
`ssh_config_path` `SEMAPHORE_SSH_PATH`	Chemin vers un fichier de configuration SSH personnalisé. Par défaut : `~/.ssh/config`.
`port` `SEMAPHORE_PORT`	Port TCP sur lequel l'interface web sera disponible. Par défaut : `:3000`
`interface` `SEMAPHORE_INTERFACE`	Adresse d'écoute (vide = toutes les interfaces). Utile si votre serveur possède plusieurs interfaces réseau.
`tmp_path` `SEMAPHORE_TMP_PATH`	Chemin vers le répertoire où sont stockés les dépôts clonés et les fichiers générés. Par défaut : /tmp/semaphore
`dirs.secrets` `SEMAPHORE_SECRETS_PATH`	Chemin vers le répertoire où sont stockés les secrets (par exemple les fichiers de token Vault). Par défaut : `/tmp/semaphore`. L'ancienne option de premier niveau `secrets_path` est toujours acceptée lorsque `dirs.secrets` n'est pas définie ou conserve sa valeur par défaut.
`dirs.repos` `SEMAPHORE_REPOS_DIR`	Chemin vers le répertoire où sont stockés les dépôts.
`dirs.ssh_agent_sockets` `SEMAPHORE_SSH_AGENT_SOCKETS_DIR`	Chemin vers le répertoire où sont stockés les sockets de l'agent SSH. Par défaut : /tmp/semaphore
`home_dir_mode` `SEMAPHORE_HOME_DIR_MODE`	Contrôle la manière dont la variable d'environnement HOME est définie pour les tâches. Options : `template_dir` (par défaut), `project_home`, `user_home`.
`max_parallel_tasks` `SEMAPHORE_MAX_PARALLEL_TASKS`	Nombre maximal de tâches parallèles pouvant être exécutées sur le serveur. Par défaut : 9999
`max_task_duration_sec` `SEMAPHORE_MAX_TASK_DURATION_SEC`	Durée maximale d'une tâche en secondes.
`max_tasks_per_template` `SEMAPHORE_MAX_TASKS_PER_TEMPLATE`	Nombre maximal de tâches récentes conservées dans la base de données pour chaque modèle.
`schedule.timezone` `SEMAPHORE_SCHEDULE_TIMEZONE`	Fuseau horaire utilisé pour la planification des tâches et des tâches cron. Par défaut : UTC
`oidc_providers` `SEMAPHORE_OIDC_PROVIDERS`	Paramètres des fournisseurs OpenID. Vous pouvez fournir plusieurs fournisseurs OpenID. Pour en savoir plus sur la configuration OpenID, consultez OpenID.
`password_login_disable` `SEMAPHORE_PASSWORD_LOGIN_DISABLED`	Interdire la connexion par mot de passe.
`non_admin_can_create_project` `SEMAPHORE_NON_ADMIN_CAN_CREATE_PROJECT`	Autoriser les utilisateurs non administrateurs à créer des projets.
`env_vars` `SEMAPHORE_ENV_VARS`	Map JSON contenant les variables d'environnement exposées aux exécutions de tâches.
`forwarded_env_vars` `SEMAPHORE_FORWARDED_ENV_VARS`	Tableau JSON des variables d'environnement de l'hôte qui seront transmises aux exécutions de tâches.
`apps` `SEMAPHORE_APPS`	Map JSON contenant la configuration des applications.
`use_remote_runner` `SEMAPHORE_USE_REMOTE_RUNNER`	Activer pour utiliser un runner distant.
`runner_registration_token` `SEMAPHORE_RUNNER_REGISTRATION_TOKEN`	Token d'amorçage utilisé par les runners pour s'enregistrer auprès du serveur.
Abonnement
`subscription.key` `SEMAPHORE_SUBSCRIPTION_KEY`	Clé ou token d'abonnement. Désactive l'activation depuis l'interface web lorsqu'elle est définie.
`subscription.key_file` `SEMAPHORE_SUBSCRIPTION_KEY_FILE`	Chemin vers le fichier contenant la clé ou le token d'abonnement.
`subscription.server_url` `SEMAPHORE_SUBSCRIPTION_SERVER_URL`	URL du serveur d'abonnement / de facturation. Par défaut : https://portal.semaphoreui.com/billing
JWT
`jwt.enabled` `SEMAPHORE_JWT_ENABLED`	Lorsque cette option est activée, Semaphore émet un JWT de courte durée pour chaque exécution de tâche et expose sa clé publique via `/.well-known/jwks.json`.
`jwt.issuer` `SEMAPHORE_JWT_ISSUER`	Valeur émise dans la revendication `iss` des JWT délivrés.
`jwt.default_ttl` `SEMAPHORE_JWT_DEFAULT_TTL`	Durée de vie par défaut d'un JWT de tâche délivré, sous forme de durée Go (par ex. `30m`, `1h`). Par défaut : 1h
`jwt.max_ttl` `SEMAPHORE_JWT_MAX_TTL`	Limite supérieure stricte du TTL des JWT défini par modèle, sous forme de durée Go. Par défaut : 24h
Runner
`runner.registration_token_file` `SEMAPHORE_RUNNER_REGISTRATION_TOKEN_FILE`	Chemin vers le fichier contenant le token d'enregistrement du runner.
`runner.token` `SEMAPHORE_RUNNER_TOKEN`	Token d'authentification du runner. Mutuellement exclusif avec `runner.token_file`.
`runner.token_file` `SEMAPHORE_RUNNER_TOKEN_FILE`	Chemin vers le fichier de token pour l'enregistrement du runner.
`runner.private_key_file` `SEMAPHORE_RUNNER_PRIVATE_KEY_FILE`	Chemin vers le fichier de clé privée du runner.
`runner.one_off` `SEMAPHORE_RUNNER_ONE_OFF`	Le runner traite un seul job puis s'arrête. Utile pour les runners dynamiques.
`runner.enabled` `SEMAPHORE_RUNNER_ENABLED`	Activer le runner.
`runner.webhook` `SEMAPHORE_RUNNER_WEBHOOK`	URL du webhook pour le runner.
`runner.name` `SEMAPHORE_RUNNER_NAME`	Nom du runner.
`runner.tags` `SEMAPHORE_RUNNER_TAGS`	Tableau JSON des tags du runner.
`runner.max_parallel_tasks` `SEMAPHORE_RUNNER_MAX_PARALLEL_TASKS`	Nombre maximal de tâches parallèles pour le runner. Par défaut : 9999.
`runner.check_interval_seconds` `SEMAPHORE_RUNNER_CHECK_INTERVAL_SECONDS`	Fréquence, en secondes, à laquelle le runner interroge le serveur pour de nouveaux jobs et remonte sa progression. Par défaut : 1. Des valeurs plus élevées réduisent le volume de requêtes au prix d'une prise en charge des jobs légèrement plus lente.
`runner.project_id` `SEMAPHORE_RUNNER_PROJECT_ID`	Restreindre le runner à un seul projet.
`runner.connection.server_ca_cert_file` `SEMAPHORE_RUNNER_SERVER_CA_CERT_FILE`	Bundle PEM utilisé pour vérifier le certificat du serveur Semaphore, en plus du magasin de confiance du système. À définir lorsque le serveur utilise un certificat auto-signé ou émis par une CA interne.
`runner.connection.skip_tls_verify` `SEMAPHORE_RUNNER_SKIP_TLS_VERIFY`	Désactiver entièrement la vérification du certificat du serveur. Non sécurisé (vulnérable aux attaques MITM) — à utiliser uniquement pour des tests.
`runner.executor` `SEMAPHORE_RUNNER_EXECUTOR`	Objet JSON contenant la configuration complète de l'exécuteur du runner (`type` plus les paramètres imbriqués `docker` ou `k8s`). À utiliser lorsque vous souhaitez définir tout le bloc exécuteur à partir d'une seule variable d'environnement.
`runner.executor.type` —	Stratégie utilisée par le runner pour exécuter chaque tâche : `local` (par défaut), `k8s` ou `docker`.
`runner.executor.k8s.kubeconfig` `SEMAPHORE_RUNNER_K8S_KUBECONFIG`	Chemin vers un fichier kubeconfig. Vide = configuration in-cluster.
`runner.executor.k8s.namespace` `SEMAPHORE_RUNNER_K8S_NAMESPACE`	Namespace dans lequel les Pods de tâche éphémères sont créés. Par défaut : semaphore
`runner.executor.k8s.image` `SEMAPHORE_RUNNER_K8S_IMAGE`	Image de conteneur par défaut pour le conteneur de build. Par défaut : semaphoreui/job:latest
`runner.executor.k8s.helper_image` `SEMAPHORE_RUNNER_K8S_HELPER_IMAGE`	Image utilisée pour le conteneur d'initialisation git-clone. Par défaut : semaphoreui/helper:latest
`runner.executor.k8s.service_account` `SEMAPHORE_RUNNER_K8S_SERVICE_ACCOUNT`	Compte de service sous lequel s'exécutent les Pods de tâche. Par défaut : default
`runner.executor.k8s.pull_secrets` `SEMAPHORE_RUNNER_K8S_PULL_SECRETS`	Liste, séparée par des virgules, des imagePullSecrets attachés à chaque Pod.
`runner.executor.k8s.poll_interval_seconds` `SEMAPHORE_RUNNER_K8S_POLL_INTERVAL_SECONDS`	Fréquence, en secondes, à laquelle l'exécuteur interroge l'état des Pods. Par défaut : 3
`runner.executor.k8s.cleanup_grace_seconds` `SEMAPHORE_RUNNER_K8S_CLEANUP_GRACE_SECONDS`	Délai de grâce, en secondes, lors de la suppression des Pods. Par défaut : 30
`runner.executor.docker.host` `SEMAPHORE_RUNNER_DOCKER_HOST`	URL du démon Docker (`unix://`, `tcp://` ou `npipe://`). Vide = environnement standard (`DOCKER_HOST`) et socket par défaut de la plateforme.
`runner.executor.docker.tls_verify` `SEMAPHORE_RUNNER_DOCKER_TLS_VERIFY`	Activer la vérification du certificat TLS pour les connexions `tcp://`.
`runner.executor.docker.cert_path` `SEMAPHORE_RUNNER_DOCKER_CERT_PATH`	Répertoire contenant ca.pem, cert.pem et key.pem pour le TLS mutuel.
`runner.executor.docker.image` `SEMAPHORE_RUNNER_DOCKER_IMAGE`	Image par défaut pour le conteneur de build. Par défaut : semaphoreui/job:latest
`runner.executor.docker.helper_image` `SEMAPHORE_RUNNER_DOCKER_HELPER_IMAGE`	Image utilisée pour le conteneur git-clone temporaire. Par défaut : semaphoreui/helper:latest
`runner.executor.docker.network` `SEMAPHORE_RUNNER_DOCKER_NETWORK`	Réseau Docker que rejoint le conteneur de build. Par défaut : bridge
`runner.executor.docker.pull_policy` `SEMAPHORE_RUNNER_DOCKER_PULL_POLICY`	Politique de récupération des images : `always`, `if-not-present` (par défaut) ou `never`.
`runner.executor.docker.cpu_limit` `SEMAPHORE_RUNNER_DOCKER_CPU_LIMIT`	Lorsque > 0, limite le CPU du conteneur de build (transmis via `--cpus`).
`runner.executor.docker.memory_limit` `SEMAPHORE_RUNNER_DOCKER_MEMORY_LIMIT`	Lorsque non vide, limite la mémoire du conteneur de build (par ex. `2g`).
`runner.executor.docker.poll_interval_seconds` `SEMAPHORE_RUNNER_DOCKER_POLL_INTERVAL_SECONDS`	Fréquence, en secondes, à laquelle l'état du conteneur est interrogé. Par défaut : 2
`runner.executor.docker.cleanup_grace_seconds` `SEMAPHORE_RUNNER_DOCKER_CLEANUP_GRACE_SECONDS`	Délai d'expiration, en secondes, transmis à `docker stop`. Par défaut : 30
`runner.executor.docker.privileged` `SEMAPHORE_RUNNER_DOCKER_PRIVILEGED`	Exécuter le conteneur de build avec `--privileged`. Dangereux ; désactivé par défaut.
Runners (flotte côté serveur)
`runners.offline_timeout_sec` `SEMAPHORE_RUNNERS_OFFLINE_TIMEOUT_SEC`	Ancienneté du heartbeat (en secondes) au-delà de laquelle un runner est considéré comme hors ligne. Ses tâches en état « starting » sont réassignées. Par défaut : 120
`runners.task_fail_timeout_sec` `SEMAPHORE_RUNNERS_TASK_FAIL_TIMEOUT_SEC`	Ancienneté du heartbeat (en secondes) au-delà de laquelle les tâches en état « running » d'un runner sont marquées comme échouées. Les valeurs inférieures à `offline_timeout_sec` sont ramenées à cette valeur. Par défaut : 420
`runners.reconcile_interval_sec` `SEMAPHORE_RUNNERS_RECONCILE_INTERVAL_SEC`	Fréquence (en secondes) à laquelle les tâches distribuées sont réconciliées avec l'état de vie des runners. Par défaut : 30
Équipes
`teams.invites_enabled` `SEMAPHORE_TEAMS_INVITES_ENABLED`	Autoriser les utilisateurs à inviter des membres dans les équipes.
`teams.invite_type` `SEMAPHORE_TEAMS_INVITE_TYPE`	Type d'invitation : `username` (par défaut), `email`, `both`.
`teams.members_can_leave` `SEMAPHORE_TEAMS_MEMBERS_CAN_LEAVE`	Autoriser les membres à quitter les équipes.
Base de données
`sqlite.host` `SEMAPHORE_DB_HOST`	Chemin vers le fichier de base de données SQLite.
`mysql.host` `SEMAPHORE_DB_HOST`	Hôte de la base de données MySQL.
`mysql.name` `SEMAPHORE_DB_NAME`	Nom de la base de données (schéma) MySQL.
`mysql.user` `SEMAPHORE_DB_USER`	Nom d'utilisateur MySQL.
`mysql.pass` `SEMAPHORE_DB_PASS`	Mot de passe de l'utilisateur MySQL.
`postgres.host` `SEMAPHORE_DB_HOST`	Hôte de la base de données Postgres.
`postgres.name` `SEMAPHORE_DB_NAME`	Nom de la base de données (schéma) Postgres.
`postgres.user` `SEMAPHORE_DB_USER`	Nom d'utilisateur Postgres.
`postgres.pass` `SEMAPHORE_DB_PASS`	Mot de passe de l'utilisateur Postgres.
`dialect` `SEMAPHORE_DB_DIALECT`	Peut être `sqlite` (par défaut), `postgres` ou `mysql`.
`*.options` `SEMAPHORE_DB_OPTIONS`	Map JSON contenant les options de connexion à la base de données.
Sécurité
`access_key_encryption` `SEMAPHORE_ACCESS_KEY_ENCRYPTION`	Clé encodée en Base64 utilisée pour chiffrer les clés d'accès stockées dans la base de données. Pour en savoir plus, consultez la référence sur le chiffrement de la base de données.
`option_encryption` `SEMAPHORE_OPTION_ENCRYPTION`	Clé encodée en Base64 utilisée pour chiffrer les options de la base de données (la clé de signature JWT) avec l'ancien schéma à clé unique (sans rotation). Utilise la clé d'accès en repli lorsqu'elle n'est pas définie.
`cookie_hash` `SEMAPHORE_COOKIE_HASH`	Clé HMAC encodée en Base64 utilisée pour signer les cookies.
`cookie_encryption` `SEMAPHORE_COOKIE_ENCRYPTION`	Clé encodée en Base64 utilisée pour chiffrer les cookies.
`web_host` `SEMAPHORE_WEB_ROOT`	Peut être utile si vous souhaitez utiliser Semaphore via un sous-chemin, par exemple : http://yourdomain.com/semaphore. N'ajoutez pas de `/` final.
`tls.enabled` `SEMAPHORE_TLS_ENABLED`	Activer ou désactiver TLS (HTTPS) pour une communication sécurisée avec le serveur Semaphore.
`tls.cert_file` `SEMAPHORE_TLS_CERT_FILE`	Chemin vers le fichier de certificat TLS.
`tls.key_file` `SEMAPHORE_TLS_KEY_FILE`	Chemin vers le fichier de clé TLS.
`tls.http_redirect_addr` `SEMAPHORE_TLS_HTTP_REDIRECT_ADDR`	Adresse (`host[:port]`) de l'écouteur de redirection HTTP→HTTPS. Mutuellement exclusif avec `tls.http_redirect_port`.
`tls.http_redirect_port` `SEMAPHORE_TLS_HTTP_REDIRECT_PORT`	Port pour rediriger le trafic HTTP vers HTTPS. Mutuellement exclusif avec `tls.http_redirect_addr`.
`mfa.totp.enabled` `SEMAPHORE_TOTP_ENABLED`	Activer l'authentification à deux facteurs via TOTP.
`mfa.totp.app_name` `SEMAPHORE_TOTP_ISSUER`	Libellé de l'émetteur (titre Semaphore) affiché dans les applications d'authentification TOTP.
`mfa.totp.allow_recovery` `SEMAPHORE_TOTP_ALLOW_RECOVERY`	Autoriser les utilisateurs à réinitialiser TOTP à l'aide d'un code de récupération.
`mfa.email.enabled` `SEMAPHORE_EMAIL_2TP_ENABLED`	Activer l'authentification multifacteur par e-mail.
`mfa.email.allow_login_as_external_user` `SEMAPHORE_EMAIL_2TP_ALLOW_LOGIN_AS_EXTERNAL_USER`	Autoriser la connexion en tant qu'utilisateur externe (e-mail uniquement).
`mfa.email.allow_create_external_user` `SEMAPHORE_EMAIL_2TP_ALLOW_CREATE_EXTERNAL_USER`	Autoriser la création d'utilisateurs externes lors de la première connexion.
`mfa.email.allowed_domains` `SEMAPHORE_EMAIL_2TP_ALLOWED_DOMAINS`	Tableau JSON des domaines e-mail autorisés.
`mfa.email.disable_for_oidc` `SEMAPHORE_EMAIL_2TP_DISABLE_FOR_OIDC`	Désactiver la MFA par e-mail pour les utilisateurs authentifiés via OIDC.
Chiffrement
`encryption.keys_file` `SEMAPHORE_ENCRYPTION_KEYS_FILE`	Chemin vers un fichier séparé contenant les trousseaux de clés de chiffrement (YAML ou JSON). Surveillé pour détecter les modifications — les changements sont appliqués sans redémarrer le serveur. Lorsqu'il n'est pas défini, l'ancien champ `access_key_encryption` est utilisé.
`encryption.keys_poll_interval` `SEMAPHORE_ENCRYPTION_KEYS_POLL_INTERVAL`	Fréquence à laquelle `keys_file` est vérifié pour détecter les modifications (une durée Go comme `15s`). `0` désactive la vérification (un SIGHUP force toujours le rechargement). Par défaut : 15s
Processus
`process.user` `SEMAPHORE_PROCESS_USER`	Utilisateur sous lequel s'exécuteront les processus encapsulés (tels qu'Ansible, Terraform ou OpenTofu).
`process.uid` `SEMAPHORE_PROCESS_UID`	ID de l'utilisateur sous lequel s'exécuteront les processus encapsulés (tels qu'Ansible, Terraform ou OpenTofu).
`process.gid` `SEMAPHORE_PROCESS_GID`	ID du groupe sous lequel s'exécuteront les processus encapsulés (tels qu'Ansible, Terraform ou OpenTofu).
`process.chroot` `SEMAPHORE_PROCESS_CHROOT`	Répertoire chroot pour les processus encapsulés.
`process.no_new_privs` `SEMAPHORE_PROCESS_NO_NEW_PRIVS`	Définir l'indicateur `no_new_privs` afin que les processus encapsulés ne puissent pas acquérir de nouveaux privilèges.
`process.app_namespaces.user` `SEMAPHORE_PROCESS_APP_NS_USER`	Isoler les UID/GID (`CLONE_NEWUSER`) pour les exécutions d'applications. Linux uniquement.
`process.app_namespaces.mount` `SEMAPHORE_PROCESS_APP_NS_MOUNT`	Masquer les points de montage de l'hôte tels que les tmpfs de secrets (`CLONE_NEWNS`) pour les exécutions d'applications. Linux uniquement.
`process.app_namespaces.pid` `SEMAPHORE_PROCESS_APP_NS_PID`	Masquer les processus de l'hôte aux exécutions d'applications (`CLONE_NEWPID`). Linux uniquement.
`process.app_namespaces.ipc` `SEMAPHORE_PROCESS_APP_NS_IPC`	Isoler les IPC SysV et les files de messages POSIX (`CLONE_NEWIPC`) pour les exécutions d'applications. Linux uniquement.
`process.app_namespaces.uts` `SEMAPHORE_PROCESS_APP_NS_UTS`	Isoler le nom d'hôte et le domaine (`CLONE_NEWUTS`) pour les exécutions d'applications. Linux uniquement.
E-mail
`email_sender` `SEMAPHORE_EMAIL_SENDER`	Adresse e-mail de l'expéditeur.
`email_host` `SEMAPHORE_EMAIL_HOST`	Nom d'hôte du serveur SMTP.
`email_port` `SEMAPHORE_EMAIL_PORT`	Port du serveur SMTP.
`email_secure` `SEMAPHORE_EMAIL_SECURE`	Activer StartTLS pour transformer une connexion SMTP non chiffrée en connexion sécurisée et chiffrée.
`email_tls` `SEMAPHORE_EMAIL_TLS`	Utiliser une connexion SSL ou TLS pour communiquer avec le serveur SMTP.
`email_tls_min_version` `SEMAPHORE_EMAIL_TLS_MIN_VERSION`	Version TLS minimale à utiliser pour la connexion.
`email_username` `SEMAPHORE_EMAIL_USERNAME`	Nom d'utilisateur pour l'authentification auprès du serveur SMTP.
`email_password` `SEMAPHORE_EMAIL_PASSWORD`	Mot de passe pour l'authentification auprès du serveur SMTP.
`email_alert` `SEMAPHORE_EMAIL_ALERT`	Indicateur qui active les alertes par e-mail.
Messageries
`telegram_alert` `SEMAPHORE_TELEGRAM_ALERT`	Définir sur True pour activer l'envoi d'alertes vers Telegram. À utiliser en combinaison avec `telegram_chat` et `telegram_token`.
`telegram_chat` `SEMAPHORE_TELEGRAM_CHAT`	Définir sur l'identifiant (Chat ID) de la conversation à laquelle envoyer les alertes. Pour en savoir plus, consultez Configuration des notifications Telegram
`telegram_token` `SEMAPHORE_TELEGRAM_TOKEN`	Définir sur le token d'autorisation du bot qui recevra la charge utile de l'alerte. Pour en savoir plus, consultez Configuration des notifications Telegram
`slack_alert` `SEMAPHORE_SLACK_ALERT`	Définir sur True pour activer l'envoi d'alertes vers Slack. À utiliser en combinaison avec `slack_url`
`slack_url` `SEMAPHORE_SLACK_URL`	L'URL du webhook Slack. Semaphore l'utilisera pour envoyer en POST des alertes JSON au format Slack à l'URL fournie.
`microsoft_teams_alert` `SEMAPHORE_MICROSOFT_TEAMS_ALERT`	Indicateur qui active les alertes Microsoft Teams.
`microsoft_teams_url` `SEMAPHORE_MICROSOFT_TEAMS_URL`	URL du webhook Microsoft Teams.
`rocketchat_alert` `SEMAPHORE_ROCKETCHAT_ALERT`	Définir sur True pour activer l'envoi d'alertes vers Rocket.Chat. À utiliser en combinaison avec `rocketchat_url`. Disponible depuis la v2.9.56.
`rocketchat_url` `SEMAPHORE_ROCKETCHAT_URL`	L'URL du webhook Rocket.Chat. Semaphore l'utilisera pour envoyer en POST des alertes JSON au format Rocket.Chat à l'URL fournie. Disponible depuis la v2.9.56.
`dingtalk_alert` `SEMAPHORE_DINGTALK_ALERT`	Activer les alertes Dingtalk.
`dingtalk_url` `SEMAPHORE_DINGTALK_URL`	URL du webhook de la messagerie Dingtalk.
`gotify_alert` `SEMAPHORE_GOTIFY_ALERT`	Activer les alertes Gotify.
`gotify_url` `SEMAPHORE_GOTIFY_URL`	URL du serveur Gotify.
`gotify_token` `SEMAPHORE_GOTIFY_TOKEN`	Token du serveur Gotify.
LDAP
`ldap_enable` `SEMAPHORE_LDAP_ENABLE`	Indicateur qui active l'authentification LDAP.
`ldap_needtls` `SEMAPHORE_LDAP_NEEDTLS`	Indicateur pour activer ou désactiver TLS pour les connexions LDAP.
`ldap_binddn` `SEMAPHORE_LDAP_BIND_DN`	Le nom distinctif (DN) utilisé pour se lier au serveur LDAP lors de l'authentification.
`ldap_bindpassword` `SEMAPHORE_LDAP_BIND_PASSWORD`	Le mot de passe utilisé pour se lier au serveur LDAP lors de l'authentification.
`ldap_server` `SEMAPHORE_LDAP_SERVER`	Le nom d'hôte et le port du serveur LDAP (par ex. ldap-server.com:1389).
`ldap_searchdn` `SEMAPHORE_LDAP_SEARCH_DN`	Le nom distinctif (DN) de base utilisé pour rechercher les utilisateurs dans l'annuaire LDAP (par ex. dc=example,dc=org).
`ldap_searchfilter` `SEMAPHORE_LDAP_SEARCH_FILTER`	Le filtre utilisé pour rechercher les utilisateurs dans l'annuaire LDAP (par ex. (&(objectClass=inetOrgPerson)(uid=%s))).
`ldap_mappings.dn` `SEMAPHORE_LDAP_MAPPING_DN`	Attribut LDAP à utiliser comme correspondance du nom distinctif (DN) pour l'authentification des utilisateurs.
`ldap_mappings.mail` `SEMAPHORE_LDAP_MAPPING_MAIL`	Attribut LDAP à utiliser comme correspondance de l'adresse e-mail pour l'authentification des utilisateurs.
`ldap_mappings.uid` `SEMAPHORE_LDAP_MAPPING_UID`	Attribut LDAP à utiliser comme correspondance de l'identifiant utilisateur (UID) pour l'authentification des utilisateurs.
`ldap_mappings.cn` `SEMAPHORE_LDAP_MAPPING_CN`	Attribut LDAP à utiliser comme correspondance du nom commun (CN) pour l'authentification des utilisateurs.
Journalisation
`log.events.format` `SEMAPHORE_EVENT_LOG_FORMAT`	Format du journal des événements. Peut être `json` ou vide pour du texte.
`log.events.enabled` `SEMAPHORE_EVENT_LOG_ENABLED`	Activer ou désactiver la journalisation des événements.
`log.events.logger` `SEMAPHORE_EVENT_LOGGER`	Map JSON contenant la configuration du logger d'événements.
`log.tasks.format` `SEMAPHORE_TASK_LOG_FORMAT`	Format du journal des tâches. Peut être `json` ou vide pour du texte.
`log.tasks.enabled` `SEMAPHORE_TASK_LOG_ENABLED`	Activer ou désactiver la journalisation des tâches.
`log.tasks.logger` `SEMAPHORE_TASK_LOGGER`	Map JSON contenant la configuration du logger de tâches.
`log.tasks.result_logger` `SEMAPHORE_TASK_RESULT_LOGGER`	Map JSON contenant la configuration du logger de résultats de tâches.
`syslog.enabled` `SEMAPHORE_SYSLOG_ENABLED`	Activer ou désactiver l'écriture des journaux vers le serveur syslog configuré.
`syslog.network` `SEMAPHORE_SYSLOG_NETWORK`	Protocole utilisé pour se connecter au serveur Syslog : `udp` ou `tcp`.
`syslog.address` `SEMAPHORE_SYSLOG_ADDRESS`	Nom d'hôte et port du serveur Syslog. Exemple : `localhost:514`.
`syslog.tag` `SEMAPHORE_SYSLOG_TAG`	Le tag utilisé pour marquer les enregistrements de Semaphore UI sur le serveur Syslog.
`syslog.format` `SEMAPHORE_SYSLOG_FORMAT`	Format des messages Syslog. Peut être `rfc5424` ou vide pour le format par défaut.
Débogage
`debugging.api_delay` `SEMAPHORE_API_DELAY`	Ajouter un délai aux réponses de l'API (à des fins de débogage).
`debugging.pprof_dump_dir` `SEMAPHORE_PPROF_DUMP_DIR`	Répertoire des fichiers de dump pprof.
Haute disponibilité (HA)
`ha.enabled` `SEMAPHORE_HA_ENABLED`	Activer le mode haute disponibilité (HA).
`ha.node_id` `SEMAPHORE_HA_NODE_ID`	Identifiant unique du nœud HA.
`ha.redis.addr` `SEMAPHORE_HA_REDIS_ADDR`	Adresse du serveur Redis utilisé pour la HA. Exemple : `localhost:6379`.
`ha.redis.db` `SEMAPHORE_HA_REDIS_DB`	Numéro de la base de données Redis.
`ha.redis.pass` `SEMAPHORE_HA_REDIS_PASS`	Mot de passe du serveur Redis.
`ha.redis.user` `SEMAPHORE_HA_REDIS_USER`	Nom d'utilisateur du serveur Redis.
`ha.redis.tls` `SEMAPHORE_HA_REDIS_TLS`	Activer TLS pour la connexion Redis.
`ha.redis.tls_skip_verify` `SEMAPHORE_HA_REDIS_TLS_SKIP_VERIFY`	Ignorer la vérification du certificat TLS pour la connexion Redis.