Configurazione

Semaphore può essere configurato in diversi modi:

Configuratore online — interfaccia web per generare la configurazione online.
File di configurazione — il metodo principale e più flessibile per configurare Semaphore.
Variabili d'ambiente — utili per deployment containerizzati o cloud-native.

Opzioni di configurazione

Elenco completo delle opzioni di configurazione disponibili:

Opzione del file di configurazione / Variabile d'ambiente	Descrizione
Generali
`git_client` `SEMAPHORE_GIT_CLIENT`	Tipo di client Git. Può essere `cmd_git` (predefinito) o `go_git`.
`git_attempts` `SEMAPHORE_GIT_ATTEMPTS`	Numero di tentativi di git clone o pull prima che il task fallisca. Utilizza un backoff esponenziale (1s, poi 2s, 4s, … fino a 60s) tra un tentativo e l'altro. Predefinito: `4`. Impostare a `1` per disabilitare i nuovi tentativi.
`ssh_config_path` `SEMAPHORE_SSH_PATH`	Percorso del file di configurazione SSH personalizzato. Predefinito: `~/.ssh/config`.
`port` `SEMAPHORE_PORT`	Porta TCP su cui sarà disponibile l'interfaccia web. Predefinito: `:3000`
`interface` `SEMAPHORE_INTERFACE`	Indirizzo di bind (vuoto = tutte le interfacce). Utile se il server dispone di più interfacce di rete.
`tmp_path` `SEMAPHORE_TMP_PATH`	Percorso della directory in cui vengono archiviati i repository clonati e i file generati. Predefinito: /tmp/semaphore
`dirs.secrets` `SEMAPHORE_SECRETS_PATH`	Percorso della directory in cui vengono archiviati i segreti (ad esempio i file dei token Vault). Predefinito: `/tmp/semaphore`. L'opzione legacy di primo livello `secrets_path` è ancora accettata quando `dirs.secrets` non è impostato o è lasciato al valore predefinito.
`dirs.repos` `SEMAPHORE_REPOS_DIR`	Percorso della directory in cui vengono archiviati i repository.
`dirs.ssh_agent_sockets` `SEMAPHORE_SSH_AGENT_SOCKETS_DIR`	Percorso della directory in cui vengono archiviati i socket dell'agente SSH. Predefinito: /tmp/semaphore
`home_dir_mode` `SEMAPHORE_HOME_DIR_MODE`	Controlla come viene impostata la variabile d'ambiente HOME per i task. Opzioni: `template_dir` (predefinito), `project_home`, `user_home`.
`max_parallel_tasks` `SEMAPHORE_MAX_PARALLEL_TASKS`	Numero massimo di task paralleli eseguibili sul server. Predefinito: 9999
`max_task_duration_sec` `SEMAPHORE_MAX_TASK_DURATION_SEC`	Durata massima di un task in secondi.
`max_tasks_per_template` `SEMAPHORE_MAX_TASKS_PER_TEMPLATE`	Numero massimo di task recenti archiviati nel database per ogni template.
`schedule.timezone` `SEMAPHORE_SCHEDULE_TIMEZONE`	Fuso orario utilizzato per la pianificazione dei task e dei job cron. Predefinito: UTC
`oidc_providers` `SEMAPHORE_OIDC_PROVIDERS`	Impostazioni dei provider OpenID. È possibile specificare più provider OpenID. Per maggiori informazioni sulla configurazione di OpenID consultare OpenID.
`password_login_disable` `SEMAPHORE_PASSWORD_LOGIN_DISABLED`	Nega l'accesso tramite password.
`non_admin_can_create_project` `SEMAPHORE_NON_ADMIN_CAN_CREATE_PROJECT`	Consente agli utenti non amministratori di creare progetti.
`env_vars` `SEMAPHORE_ENV_VARS`	Mappa JSON contenente le variabili d'ambiente esposte alle esecuzioni dei task.
`forwarded_env_vars` `SEMAPHORE_FORWARDED_ENV_VARS`	Array JSON delle variabili d'ambiente dell'host che verranno inoltrate alle esecuzioni dei task.
`apps` `SEMAPHORE_APPS`	Mappa JSON contenente la configurazione delle app.
`use_remote_runner` `SEMAPHORE_USE_REMOTE_RUNNER`	Abilitare per utilizzare un runner remoto.
`runner_registration_token` `SEMAPHORE_RUNNER_REGISTRATION_TOKEN`	Token di bootstrap utilizzato dai runner per registrarsi sul server.
Sottoscrizione
`subscription.key` `SEMAPHORE_SUBSCRIPTION_KEY`	Chiave o token di sottoscrizione. Se impostato, disabilita l'attivazione dall'interfaccia web.
`subscription.key_file` `SEMAPHORE_SUBSCRIPTION_KEY_FILE`	Percorso del file contenente la chiave o il token di sottoscrizione.
`subscription.server_url` `SEMAPHORE_SUBSCRIPTION_SERVER_URL`	URL del server di sottoscrizione / fatturazione. Predefinito: https://portal.semaphoreui.com/billing
JWT
`jwt.enabled` `SEMAPHORE_JWT_ENABLED`	Se abilitato, Semaphore genera un JWT di breve durata per ogni esecuzione di task ed espone la relativa chiave pubblica tramite `/.well-known/jwks.json`.
`jwt.issuer` `SEMAPHORE_JWT_ISSUER`	Valore emesso nel claim `iss` dei JWT rilasciati.
`jwt.default_ttl` `SEMAPHORE_JWT_DEFAULT_TTL`	Durata predefinita di un JWT di task rilasciato, espressa come durata Go (ad es. `30m`, `1h`). Predefinito: 1h
`jwt.max_ttl` `SEMAPHORE_JWT_MAX_TTL`	Limite massimo assoluto per il TTL dei JWT per template, espresso come durata Go. Predefinito: 24h
Runner
`runner.registration_token_file` `SEMAPHORE_RUNNER_REGISTRATION_TOKEN_FILE`	Percorso del file contenente il token di registrazione del runner.
`runner.token` `SEMAPHORE_RUNNER_TOKEN`	Token di autenticazione del runner. Mutuamente esclusivo con `runner.token_file`.
`runner.token_file` `SEMAPHORE_RUNNER_TOKEN_FILE`	Percorso del file del token per la registrazione del runner.
`runner.private_key_file` `SEMAPHORE_RUNNER_PRIVATE_KEY_FILE`	Percorso del file della chiave privata del runner.
`runner.one_off` `SEMAPHORE_RUNNER_ONE_OFF`	Il runner elabora un singolo job e termina. Utile per i runner dinamici.
`runner.enabled` `SEMAPHORE_RUNNER_ENABLED`	Abilita il runner.
`runner.webhook` `SEMAPHORE_RUNNER_WEBHOOK`	URL del webhook per il runner.
`runner.name` `SEMAPHORE_RUNNER_NAME`	Nome del runner.
`runner.tags` `SEMAPHORE_RUNNER_TAGS`	Array JSON dei tag del runner.
`runner.max_parallel_tasks` `SEMAPHORE_RUNNER_MAX_PARALLEL_TASKS`	Numero massimo di task paralleli per il runner. Predefinito: 9999.
`runner.check_interval_seconds` `SEMAPHORE_RUNNER_CHECK_INTERVAL_SECONDS`	Frequenza, in secondi, con cui il runner interroga il server per nuovi job e riporta l'avanzamento. Predefinito: 1. Valori più alti riducono il volume delle richieste a costo di una presa in carico dei job leggermente più lenta.
`runner.project_id` `SEMAPHORE_RUNNER_PROJECT_ID`	Limita il runner a un singolo progetto.
`runner.connection.server_ca_cert_file` `SEMAPHORE_RUNNER_SERVER_CA_CERT_FILE`	Bundle PEM utilizzato per verificare il certificato del server Semaphore, in aggiunta all'archivio di certificati attendibili del sistema. Da impostare quando il server utilizza un certificato autofirmato o emesso da una CA interna.
`runner.connection.skip_tls_verify` `SEMAPHORE_RUNNER_SKIP_TLS_VERIFY`	Disabilita completamente la verifica del certificato del server. Non sicuro (vulnerabile ad attacchi MITM) — da utilizzare solo per i test.
`runner.executor` `SEMAPHORE_RUNNER_EXECUTOR`	Oggetto JSON con la configurazione completa dell'executor del runner (`type` più le impostazioni annidate `docker` o `k8s`). Da utilizzare quando si desidera impostare l'intero blocco executor da una singola variabile d'ambiente.
`runner.executor.type` —	Strategia utilizzata dal runner per eseguire ogni task: `local` (predefinito), `k8s` o `docker`.
`runner.executor.k8s.kubeconfig` `SEMAPHORE_RUNNER_K8S_KUBECONFIG`	Percorso di un file kubeconfig. Vuoto = configurazione in-cluster.
`runner.executor.k8s.namespace` `SEMAPHORE_RUNNER_K8S_NAMESPACE`	Namespace in cui vengono creati i Pod effimeri dei task. Predefinito: semaphore
`runner.executor.k8s.image` `SEMAPHORE_RUNNER_K8S_IMAGE`	Immagine container predefinita per il container di build. Predefinito: semaphoreui/job:latest
`runner.executor.k8s.helper_image` `SEMAPHORE_RUNNER_K8S_HELPER_IMAGE`	Immagine utilizzata per l'init container di git-clone. Predefinito: semaphoreui/helper:latest
`runner.executor.k8s.service_account` `SEMAPHORE_RUNNER_K8S_SERVICE_ACCOUNT`	Service account con cui vengono eseguiti i Pod dei task. Predefinito: default
`runner.executor.k8s.pull_secrets` `SEMAPHORE_RUNNER_K8S_PULL_SECRETS`	Elenco separato da virgole di imagePullSecrets associati a ogni Pod.
`runner.executor.k8s.poll_interval_seconds` `SEMAPHORE_RUNNER_K8S_POLL_INTERVAL_SECONDS`	Frequenza, in secondi, con cui l'executor interroga lo stato dei Pod. Predefinito: 3
`runner.executor.k8s.cleanup_grace_seconds` `SEMAPHORE_RUNNER_K8S_CLEANUP_GRACE_SECONDS`	Periodo di tolleranza, in secondi, per l'eliminazione dei Pod. Predefinito: 30
`runner.executor.docker.host` `SEMAPHORE_RUNNER_DOCKER_HOST`	URL del daemon Docker (`unix://`, `tcp://` o `npipe://`). Vuoto = ambiente standard (`DOCKER_HOST`) e socket predefinito della piattaforma.
`runner.executor.docker.tls_verify` `SEMAPHORE_RUNNER_DOCKER_TLS_VERIFY`	Abilita la verifica del certificato TLS per le connessioni `tcp://`.
`runner.executor.docker.cert_path` `SEMAPHORE_RUNNER_DOCKER_CERT_PATH`	Directory contenente ca.pem, cert.pem e key.pem per il TLS reciproco.
`runner.executor.docker.image` `SEMAPHORE_RUNNER_DOCKER_IMAGE`	Immagine predefinita per il container di build. Predefinito: semaphoreui/job:latest
`runner.executor.docker.helper_image` `SEMAPHORE_RUNNER_DOCKER_HELPER_IMAGE`	Immagine utilizzata per il container temporaneo di git-clone. Predefinito: semaphoreui/helper:latest
`runner.executor.docker.network` `SEMAPHORE_RUNNER_DOCKER_NETWORK`	Rete Docker a cui si collega il container di build. Predefinito: bridge
`runner.executor.docker.pull_policy` `SEMAPHORE_RUNNER_DOCKER_PULL_POLICY`	Politica di pull delle immagini: `always`, `if-not-present` (predefinito) o `never`.
`runner.executor.docker.cpu_limit` `SEMAPHORE_RUNNER_DOCKER_CPU_LIMIT`	Se > 0, limita la CPU del container di build (passato come `--cpus`).
`runner.executor.docker.memory_limit` `SEMAPHORE_RUNNER_DOCKER_MEMORY_LIMIT`	Se non vuoto, limita la memoria del container di build (ad es. `2g`).
`runner.executor.docker.poll_interval_seconds` `SEMAPHORE_RUNNER_DOCKER_POLL_INTERVAL_SECONDS`	Frequenza, in secondi, con cui viene interrogato lo stato del container. Predefinito: 2
`runner.executor.docker.cleanup_grace_seconds` `SEMAPHORE_RUNNER_DOCKER_CLEANUP_GRACE_SECONDS`	Timeout passato a `docker stop`, in secondi. Predefinito: 30
`runner.executor.docker.privileged` `SEMAPHORE_RUNNER_DOCKER_PRIVILEGED`	Esegue il container di build con `--privileged`. Pericoloso; disabilitato per impostazione predefinita.
Runner (flotta lato server)
`runners.offline_timeout_sec` `SEMAPHORE_RUNNERS_OFFLINE_TIMEOUT_SEC`	Anzianità dell'heartbeat (secondi) oltre la quale un runner viene considerato offline. I suoi task in stato "starting" vengono riassegnati. Predefinito: 120
`runners.task_fail_timeout_sec` `SEMAPHORE_RUNNERS_TASK_FAIL_TIMEOUT_SEC`	Anzianità dell'heartbeat (secondi) oltre la quale i task in stato "running" di un runner vengono contrassegnati come falliti. I valori inferiori a `offline_timeout_sec` vengono portati a tale valore. Predefinito: 420
`runners.reconcile_interval_sec` `SEMAPHORE_RUNNERS_RECONCILE_INTERVAL_SEC`	Frequenza (secondi) con cui i task assegnati vengono riconciliati con lo stato di attività dei runner. Predefinito: 30
Team
`teams.invites_enabled` `SEMAPHORE_TEAMS_INVITES_ENABLED`	Consente agli utenti di invitare membri nei team.
`teams.invite_type` `SEMAPHORE_TEAMS_INVITE_TYPE`	Tipo di invito: `username` (predefinito), `email`, `both`.
`teams.members_can_leave` `SEMAPHORE_TEAMS_MEMBERS_CAN_LEAVE`	Consente ai membri di lasciare i team.
Database
`sqlite.host` `SEMAPHORE_DB_HOST`	Percorso del file del database SQLite.
`mysql.host` `SEMAPHORE_DB_HOST`	Host del database MySQL.
`mysql.name` `SEMAPHORE_DB_NAME`	Nome del database (schema) MySQL.
`mysql.user` `SEMAPHORE_DB_USER`	Nome utente MySQL.
`mysql.pass` `SEMAPHORE_DB_PASS`	Password dell'utente MySQL.
`postgres.host` `SEMAPHORE_DB_HOST`	Host del database Postgres.
`postgres.name` `SEMAPHORE_DB_NAME`	Nome del database (schema) Postgres.
`postgres.user` `SEMAPHORE_DB_USER`	Nome utente Postgres.
`postgres.pass` `SEMAPHORE_DB_PASS`	Password dell'utente Postgres.
`dialect` `SEMAPHORE_DB_DIALECT`	Può essere `sqlite` (predefinito), `postgres` o `mysql`.
`*.options` `SEMAPHORE_DB_OPTIONS`	Mappa JSON contenente le opzioni di connessione al database.
Sicurezza
`access_key_encryption` `SEMAPHORE_ACCESS_KEY_ENCRYPTION`	Chiave codificata in Base64 utilizzata per cifrare le chiavi di accesso archiviate nel database. Per maggiori informazioni consultare il riferimento sulla cifratura del database.
`option_encryption` `SEMAPHORE_OPTION_ENCRYPTION`	Chiave codificata in Base64 utilizzata per cifrare le opzioni del DB (la chiave di firma JWT) con il vecchio schema a chiave singola (senza rotazione). Se non impostata, viene utilizzata la chiave di accesso.
`cookie_hash` `SEMAPHORE_COOKIE_HASH`	Chiave HMAC codificata in Base64 utilizzata per firmare i cookie.
`cookie_encryption` `SEMAPHORE_COOKIE_ENCRYPTION`	Chiave codificata in Base64 utilizzata per cifrare i cookie.
`web_host` `SEMAPHORE_WEB_ROOT`	Può essere utile se si desidera utilizzare Semaphore tramite un sottopercorso, ad esempio: http://yourdomain.com/semaphore. Non aggiungere una `/` finale.
`tls.enabled` `SEMAPHORE_TLS_ENABLED`	Abilita o disabilita TLS (HTTPS) per la comunicazione sicura con il server Semaphore.
`tls.cert_file` `SEMAPHORE_TLS_CERT_FILE`	Percorso del file del certificato TLS.
`tls.key_file` `SEMAPHORE_TLS_KEY_FILE`	Percorso del file della chiave TLS.
`tls.http_redirect_addr` `SEMAPHORE_TLS_HTTP_REDIRECT_ADDR`	Indirizzo (`host[:port]`) del listener per il reindirizzamento HTTP→HTTPS. Mutuamente esclusivo con `tls.http_redirect_port`.
`tls.http_redirect_port` `SEMAPHORE_TLS_HTTP_REDIRECT_PORT`	Porta per reindirizzare il traffico HTTP verso HTTPS. Mutuamente esclusivo con `tls.http_redirect_addr`.
`mfa.totp.enabled` `SEMAPHORE_TOTP_ENABLED`	Abilita l'autenticazione a due fattori tramite TOTP.
`mfa.totp.app_name` `SEMAPHORE_TOTP_ISSUER`	Etichetta dell'issuer (titolo di Semaphore) mostrata nelle app di autenticazione TOTP.
`mfa.totp.allow_recovery` `SEMAPHORE_TOTP_ALLOW_RECOVERY`	Consente agli utenti di reimpostare il TOTP utilizzando un codice di recupero.
`mfa.email.enabled` `SEMAPHORE_EMAIL_2TP_ENABLED`	Abilita l'autenticazione a più fattori tramite email.
`mfa.email.allow_login_as_external_user` `SEMAPHORE_EMAIL_2TP_ALLOW_LOGIN_AS_EXTERNAL_USER`	Consente l'accesso come utente esterno (solo email).
`mfa.email.allow_create_external_user` `SEMAPHORE_EMAIL_2TP_ALLOW_CREATE_EXTERNAL_USER`	Consente la creazione di utenti esterni al primo accesso.
`mfa.email.allowed_domains` `SEMAPHORE_EMAIL_2TP_ALLOWED_DOMAINS`	Array JSON dei domini email consentiti.
`mfa.email.disable_for_oidc` `SEMAPHORE_EMAIL_2TP_DISABLE_FOR_OIDC`	Disabilita l'MFA via email per gli utenti autenticati tramite OIDC.
Cifratura
`encryption.keys_file` `SEMAPHORE_ENCRYPTION_KEYS_FILE`	Percorso di un file separato contenente i keyring di cifratura (YAML o JSON). Il file viene monitorato: le modifiche vengono applicate senza riavviare il server. Se non impostato, viene utilizzato il campo legacy `access_key_encryption`.
`encryption.keys_poll_interval` `SEMAPHORE_ENCRYPTION_KEYS_POLL_INTERVAL`	Frequenza con cui `keys_file` viene controllato per rilevare modifiche (una durata Go come `15s`). `0` disabilita il controllo periodico (un SIGHUP forza comunque il ricaricamento). Predefinito: 15s
Processo
`process.user` `SEMAPHORE_PROCESS_USER`	Utente con cui verranno eseguiti i processi incapsulati (come Ansible, Terraform o OpenTofu).
`process.uid` `SEMAPHORE_PROCESS_UID`	ID dell'utente con cui verranno eseguiti i processi incapsulati (come Ansible, Terraform o OpenTofu).
`process.gid` `SEMAPHORE_PROCESS_GID`	ID del gruppo con cui verranno eseguiti i processi incapsulati (come Ansible, Terraform o OpenTofu).
`process.chroot` `SEMAPHORE_PROCESS_CHROOT`	Directory chroot per i processi incapsulati.
`process.no_new_privs` `SEMAPHORE_PROCESS_NO_NEW_PRIVS`	Imposta il flag `no_new_privs` in modo che i processi incapsulati non possano acquisire nuovi privilegi.
`process.app_namespaces.user` `SEMAPHORE_PROCESS_APP_NS_USER`	Isola UID/GID (`CLONE_NEWUSER`) per le esecuzioni delle app. Solo Linux.
`process.app_namespaces.mount` `SEMAPHORE_PROCESS_APP_NS_MOUNT`	Nasconde i punti di mount dell'host, come i tmpfs dei segreti (`CLONE_NEWNS`), per le esecuzioni delle app. Solo Linux.
`process.app_namespaces.pid` `SEMAPHORE_PROCESS_APP_NS_PID`	Nasconde i processi dell'host alle esecuzioni delle app (`CLONE_NEWPID`). Solo Linux.
`process.app_namespaces.ipc` `SEMAPHORE_PROCESS_APP_NS_IPC`	Isola l'IPC SysV e le code di messaggi POSIX (`CLONE_NEWIPC`) per le esecuzioni delle app. Solo Linux.
`process.app_namespaces.uts` `SEMAPHORE_PROCESS_APP_NS_UTS`	Isola hostname e dominio (`CLONE_NEWUTS`) per le esecuzioni delle app. Solo Linux.
Email
`email_sender` `SEMAPHORE_EMAIL_SENDER`	Indirizzo email del mittente.
`email_host` `SEMAPHORE_EMAIL_HOST`	Hostname del server SMTP.
`email_port` `SEMAPHORE_EMAIL_PORT`	Porta del server SMTP.
`email_secure` `SEMAPHORE_EMAIL_SECURE`	Abilita StartTLS per promuovere una connessione SMTP non cifrata a una connessione sicura e cifrata.
`email_tls` `SEMAPHORE_EMAIL_TLS`	Utilizza una connessione SSL o TLS per la comunicazione con il server SMTP.
`email_tls_min_version` `SEMAPHORE_EMAIL_TLS_MIN_VERSION`	Versione minima di TLS da utilizzare per la connessione.
`email_username` `SEMAPHORE_EMAIL_USERNAME`	Nome utente per l'autenticazione sul server SMTP.
`email_password` `SEMAPHORE_EMAIL_PASSWORD`	Password per l'autenticazione sul server SMTP.
`email_alert` `SEMAPHORE_EMAIL_ALERT`	Flag che abilita gli avvisi via email.
Messaggistica
`telegram_alert` `SEMAPHORE_TELEGRAM_ALERT`	Impostare a True per abilitare l'invio degli avvisi a Telegram. Da utilizzare in combinazione con `telegram_chat` e `telegram_token`.
`telegram_chat` `SEMAPHORE_TELEGRAM_CHAT`	Impostare al Chat ID della chat a cui inviare gli avvisi. Per maggiori informazioni consultare Configurazione delle notifiche Telegram
`telegram_token` `SEMAPHORE_TELEGRAM_TOKEN`	Impostare al token di autorizzazione del bot che riceverà il payload dell'avviso. Per maggiori informazioni consultare Configurazione delle notifiche Telegram
`slack_alert` `SEMAPHORE_SLACK_ALERT`	Impostare a True per abilitare l'invio degli avvisi a Slack. Da utilizzare in combinazione con `slack_url`
`slack_url` `SEMAPHORE_SLACK_URL`	URL del webhook Slack. Semaphore lo utilizzerà per inviare tramite POST avvisi JSON in formato Slack all'URL specificato.
`microsoft_teams_alert` `SEMAPHORE_MICROSOFT_TEAMS_ALERT`	Flag che abilita gli avvisi Microsoft Teams.
`microsoft_teams_url` `SEMAPHORE_MICROSOFT_TEAMS_URL`	URL del webhook Microsoft Teams.
`rocketchat_alert` `SEMAPHORE_ROCKETCHAT_ALERT`	Impostare a True per abilitare l'invio degli avvisi a Rocket.Chat. Da utilizzare in combinazione con `rocketchat_url`. Disponibile dalla versione v2.9.56.
`rocketchat_url` `SEMAPHORE_ROCKETCHAT_URL`	URL del webhook Rocket.Chat. Semaphore lo utilizzerà per inviare tramite POST avvisi JSON in formato Rocket.Chat all'URL specificato. Disponibile dalla versione v2.9.56.
`dingtalk_alert` `SEMAPHORE_DINGTALK_ALERT`	Abilita gli avvisi Dingtalk.
`dingtalk_url` `SEMAPHORE_DINGTALK_URL`	URL del webhook della messaggistica Dingtalk.
`gotify_alert` `SEMAPHORE_GOTIFY_ALERT`	Abilita gli avvisi Gotify.
`gotify_url` `SEMAPHORE_GOTIFY_URL`	URL del server Gotify.
`gotify_token` `SEMAPHORE_GOTIFY_TOKEN`	Token del server Gotify.
LDAP
`ldap_enable` `SEMAPHORE_LDAP_ENABLE`	Flag che abilita l'autenticazione LDAP.
`ldap_needtls` `SEMAPHORE_LDAP_NEEDTLS`	Flag per abilitare o disabilitare TLS per le connessioni LDAP.
`ldap_binddn` `SEMAPHORE_LDAP_BIND_DN`	Il distinguished name (DN) utilizzato per il bind al server LDAP per l'autenticazione.
`ldap_bindpassword` `SEMAPHORE_LDAP_BIND_PASSWORD`	La password utilizzata per il bind al server LDAP per l'autenticazione.
`ldap_server` `SEMAPHORE_LDAP_SERVER`	Hostname e porta del server LDAP (ad es. ldap-server.com:1389).
`ldap_searchdn` `SEMAPHORE_LDAP_SEARCH_DN`	Il distinguished name (DN) di base utilizzato per la ricerca degli utenti nella directory LDAP (ad es. dc=example,dc=org).
`ldap_searchfilter` `SEMAPHORE_LDAP_SEARCH_FILTER`	Il filtro utilizzato per la ricerca degli utenti nella directory LDAP (ad es. (&(objectClass=inetOrgPerson)(uid=%s))).
`ldap_mappings.dn` `SEMAPHORE_LDAP_MAPPING_DN`	Attributo LDAP da utilizzare come mapping del distinguished name (DN) per l'autenticazione degli utenti.
`ldap_mappings.mail` `SEMAPHORE_LDAP_MAPPING_MAIL`	Attributo LDAP da utilizzare come mapping dell'indirizzo email per l'autenticazione degli utenti.
`ldap_mappings.uid` `SEMAPHORE_LDAP_MAPPING_UID`	Attributo LDAP da utilizzare come mapping dell'ID utente (UID) per l'autenticazione degli utenti.
`ldap_mappings.cn` `SEMAPHORE_LDAP_MAPPING_CN`	Attributo LDAP da utilizzare come mapping del common name (CN) per l'autenticazione degli utenti.
Logging
`log.events.format` `SEMAPHORE_EVENT_LOG_FORMAT`	Formato del log degli eventi. Può essere `json` oppure vuoto per il formato testuale.
`log.events.enabled` `SEMAPHORE_EVENT_LOG_ENABLED`	Abilita o disabilita il logging degli eventi.
`log.events.logger` `SEMAPHORE_EVENT_LOGGER`	Mappa JSON contenente la configurazione del logger degli eventi.
`log.tasks.format` `SEMAPHORE_TASK_LOG_FORMAT`	Formato del log dei task. Può essere `json` oppure vuoto per il formato testuale.
`log.tasks.enabled` `SEMAPHORE_TASK_LOG_ENABLED`	Abilita o disabilita il logging dei task.
`log.tasks.logger` `SEMAPHORE_TASK_LOGGER`	Mappa JSON contenente la configurazione del logger dei task.
`log.tasks.result_logger` `SEMAPHORE_TASK_RESULT_LOGGER`	Mappa JSON contenente la configurazione del logger dei risultati dei task.
`syslog.enabled` `SEMAPHORE_SYSLOG_ENABLED`	Abilita o disabilita la scrittura dei log sul server syslog configurato.
`syslog.network` `SEMAPHORE_SYSLOG_NETWORK`	Protocollo utilizzato per la connessione al server Syslog: `udp` o `tcp`.
`syslog.address` `SEMAPHORE_SYSLOG_ADDRESS`	Hostname e porta del server Syslog. Esempio: `localhost:514`.
`syslog.tag` `SEMAPHORE_SYSLOG_TAG`	Il tag utilizzato per contrassegnare i record di Semaphore UI sul server Syslog.
`syslog.format` `SEMAPHORE_SYSLOG_FORMAT`	Formato dei messaggi Syslog. Può essere `rfc5424` oppure vuoto per il formato predefinito.
Debug
`debugging.api_delay` `SEMAPHORE_API_DELAY`	Aggiunge un ritardo alle risposte dell'API (a scopo di debug).
`debugging.pprof_dump_dir` `SEMAPHORE_PPROF_DUMP_DIR`	Directory per i file di dump pprof.
Alta disponibilità (HA)
`ha.enabled` `SEMAPHORE_HA_ENABLED`	Abilita la modalità ad alta disponibilità (HA).
`ha.node_id` `SEMAPHORE_HA_NODE_ID`	Identificatore univoco del nodo HA.
`ha.redis.addr` `SEMAPHORE_HA_REDIS_ADDR`	Indirizzo del server Redis utilizzato per l'HA. Esempio: `localhost:6379`.
`ha.redis.db` `SEMAPHORE_HA_REDIS_DB`	Numero del database Redis.
`ha.redis.pass` `SEMAPHORE_HA_REDIS_PASS`	Password del server Redis.
`ha.redis.user` `SEMAPHORE_HA_REDIS_USER`	Nome utente del server Redis.
`ha.redis.tls` `SEMAPHORE_HA_REDIS_TLS`	Abilita TLS per la connessione a Redis.
`ha.redis.tls_skip_verify` `SEMAPHORE_HA_REDIS_TLS_SKIP_VERIFY`	Ignora la verifica del certificato TLS per la connessione a Redis.