snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-docs/l/it/developers/self-host/capabilities/docker-compose.mdx

@@ -0,0 +1,262 @@
+---
+title: Docker Compose
+icon: docker
+---
+
+<Warning>
+I container Docker sono destinati all'hosting in produzione o al self-hosting. Per contribuire, consulta [Configurazione locale](/l/it/developers/contribute/capabilities/local-setup).
+</Warning>
+
+## Panoramica
+
+Questa guida fornisce istruzioni passo passo per installare e configurare l'applicazione Twenty usando Docker Compose. L'obiettivo è rendere il processo semplice ed evitare gli errori comuni che potrebbero compromettere il tuo setup.
+
+**Importante:** Modifica solo le impostazioni esplicitamente menzionate in questa guida. Modificare altre configurazioni potrebbe portare a problemi.
+
+Consulta [Configurazione delle variabili di ambiente](/l/it/developers/self-host/capabilities/setup) per configurazioni avanzate. Tutte le variabili di ambiente devono essere dichiarate nel file `docker-compose.yml` a livello di server e/o di worker, a seconda della variabile.
+
+## Requisiti di Sistema
+
+* RAM: Assicurati che il tuo ambiente abbia almeno 2GB di RAM. Memoria insufficiente può causare arresti anomali dei processi.
+* Docker & Docker Compose: Assicurati che entrambi siano installati e aggiornati.
+
+## Opzione 1: Script a riga singola
+
+Installa l'ultima versione stabile di Twenty con un unico comando:
+
+```bash
+bash <(curl -sL https://raw.githubusercontent.com/twentyhq/twenty/main/packages/twenty-docker/scripts/install.sh)
+```
+
+Per installare una versione o un ramo specifico:
+
+```bash
+VERSION=vx.y.z BRANCH=branch-name bash <(curl -sL https://raw.githubusercontent.com/twentyhq/twenty/main/packages/twenty-docker/scripts/install.sh)
+```
+
+* Sostituisci x.y.z con il numero di versione desiderato.
+* Sostituisci nome-ramo con il nome del ramo che vuoi installare.
+
+## Opzione 2: Passaggi manuali
+
+Segui questi passaggi per un setup manuale.
+
+### Passo 1: Configura il File di Ambiente
+
+1. **Crea il File .env**
+
+   Copia il file di ambiente di esempio in un nuovo file .env nella tua directory di lavoro:
+
+   ```bash
+   curl -o .env https://raw.githubusercontent.com/twentyhq/twenty/refs/heads/main/packages/twenty-docker/.env.example
+   ```
+
+2. **Genera una chiave di cifratura**
+
+   Esegui il seguente comando per generare una stringa casuale unica:
+
+   ```bash
+   openssl rand -base64 32
+   ```
+
+   **Importante:** Tieni questo valore segreto / non condividerlo. La perdita di `ENCRYPTION_KEY` significa perdere l'accesso a tutti i segreti archiviati nel database (token OAuth, variabili dell'applicazione, segreti TOTP, ecc.).
+
+3. **Aggiorna il `.env`**
+
+   Sostituisci il valore segnaposto nel tuo file .env con il token generato:
+
+   ```ini
+   ENCRYPTION_KEY=random_string
+   ```
+
+   Consulta la [Guida alla rotazione delle chiavi](/l/it/developers/self-host/capabilities/key-rotation) per le istruzioni su come ruotarla senza tempi di inattività.
+
+4. **Imposta la Password di Postgres**
+
+   Aggiorna il valore `PG_DATABASE_PASSWORD` nel file .env con una password forte senza caratteri speciali.
+
+   ```ini
+   PG_DATABASE_PASSWORD=my_strong_password
+   ```
+
+### Passo 2: Ottieni il File Docker Compose
+
+Scarica il file `docker-compose.yml` nella tua directory di lavoro:
+
+```bash
+curl -o docker-compose.yml https://raw.githubusercontent.com/twentyhq/twenty/refs/heads/main/packages/twenty-docker/docker-compose.yml
+```
+
+### Passo 3: Avvia l'Applicazione
+
+Avvia i container Docker:
+
+```bash
+docker compose up -d
+```
+
+### Passo 4: Accedi all'Applicazione
+
+Se ospiti twentyCRM sul tuo computer, apri il browser e naviga a [http://localhost:3000](http://localhost:3000).
+
+Se lo ospiti su un server, controlla che il server sia in esecuzione e che tutto sia ok con
+
+```bash
+curl http://localhost:3000
+```
+
+## Configurazione
+
+### Esponi Twenty per Accesso Esterno
+
+Per impostazione predefinita, Twenty gira su `localhost` alla porta `3000`. L'interfaccia utente risolve l'API dall'origine del browser, quindi viene caricata da qualsiasi hostname che raggiunga il container — ma imposta comunque `SERVER_URL` sul tuo URL pubblico: il server lo usa per i link generati (email, callback OAuth) e per rilevare l'HTTPS per i cookie sicuri.
+
+#### Comprendere `SERVER_URL`
+
+* **Protocollo:** Usa `http` o `https` a seconda della tua configurazione.
+  * Usa `http` se non hai configurato SSL.
+  * Usa `https` se hai configurato SSL.
+* **Dominio/IP:** Questo è il nome del dominio o indirizzo IP dove la tua applicazione è accessibile.
+* **Porta:** Includi il numero di porta se non stai usando le porte predefinite (`80` per `http`, `443` per `https`).
+
+### Requisiti SSL
+
+SSL (HTTPS) è necessario affinché alcune caratteristiche del browser funzionino correttamente. Mentre queste caratteristiche potrebbero funzionare durante lo sviluppo locale (poiché i browser trattano localhost in modo diverso), è necessario un setup SSL adeguato quando si ospita Twenty su un dominio regolare.
+
+Ad esempio, l'API degli appunti potrebbe richiedere un contesto sicuro - alcune funzionalità come i pulsanti di copia in tutta l'applicazione potrebbero non funzionare senza HTTPS abilitato.
+
+Raccomandiamo fortemente di configurare Twenty dietro un proxy inverso con terminazione SSL per una sicurezza e funzionalità ottimali.
+
+#### Configurare `SERVER_URL`
+
+1. **Determina il tuo URL di Accesso**
+   * **Senza Proxy Inverso (Accesso Diretto):**
+
+     Se accedi all'applicazione direttamente senza un proxy inverso:
+
+     ```ini
+     SERVER_URL=http://your-domain-or-ip:3000
+     ```
+
+   * **Con Proxy Inverso (Porte Standard):**
+
+     Se usi un proxy inverso come Nginx o Traefik e hai configurato SSL:
+
+     ```ini
+     SERVER_URL=https://your-domain-or-ip
+     ```
+
+   * **Con Proxy Inverso (Porte Personalizzate):**
+
+     Se usi porte non standard:
+
+     ```ini
+     SERVER_URL=https://your-domain-or-ip:custom-port
+     ```
+
+2. **Aggiorna il File `.env`**
+
+   Apri il tuo file `.env` e aggiorna il `SERVER_URL`:
+
+   ```ini
+   SERVER_URL=http(s)://your-domain-or-ip:your-port
+   ```
+
+   **Esempi:**
+
+   * Accesso diretto senza SSL:
+     ```ini
+     SERVER_URL=http://123.45.67.89:3000
+     ```
+   * Accesso tramite dominio con SSL:
+     ```ini
+     SERVER_URL=https://mytwentyapp.com
+     ```
+
+3. **Riavvia l'Applicazione**
+
+   Per rendere effettive le modifiche, riavvia i container Docker:
+
+   ```bash
+   docker compose down
+   docker compose up -d
+   ```
+
+#### Considerazioni
+
+* **Configurazione del Reverse Proxy:**
+
+  Assicurati che il tuo reverse proxy inoltri le richieste alla porta interna corretta (`3000` per impostazione predefinita). Configura la terminazione SSL e tutte le intestazioni necessarie.
+
+* **Impostazioni Firewall:**
+
+  Apri le porte necessarie nel tuo firewall per consentire l'accesso esterno.
+
+* **Coerenza:**
+
+  Il `SERVER_URL` deve corrispondere a come gli utenti accedono alla tua applicazione nei loro browser.
+
+#### Persistenza
+
+* **Volumi di Dati:**
+
+  La configurazione di Docker Compose utilizza volumi per mantenere i dati per il database e l'archiviazione del server.
+
+* **Ambienti Senza Stato:**
+
+  Se si distribuisce in un ambiente senza stato (ad esempio, alcuni servizi di cloud), configura l'archiviazione esterna per mantenere i dati.
+
+## Backup e ripristino
+
+I backup regolari proteggono i dati del tuo CRM dalla perdita.
+
+### Crea un backup del database
+
+```bash
+docker exec twenty-postgres pg_dump -U postgres twenty > backup_$(date +%Y%m%d).sql
+```
+
+### Automatizza i backup giornalieri
+
+Aggiungi al tuo crontab (`crontab -e`):
+
+```bash
+0 2 * * * docker exec twenty-postgres pg_dump -U postgres twenty > /backups/twenty_$(date +\%Y\%m\%d).sql
+```
+
+### Ripristina dal backup
+
+1. Arresta l'applicazione:
+
+```bash
+docker compose stop server worker
+```
+
+2. Ripristina il database:
+
+```bash
+docker exec -i twenty-postgres psql -U postgres twenty < backup_20240115.sql
+```
+
+3. Riavvia i servizi:
+
+```bash
+docker compose up -d
+```
+
+### Pratiche migliori per i backup
+
+* **Esegui regolarmente test di ripristino** — verifica che i backup funzionino davvero
+* **Conserva i backup off-site** — usa l'archiviazione cloud (S3, GCS, ecc.)
+* **Crittografa i dati sensibili** — proteggi i backup con la crittografia
+* **Mantieni più copie** — conserva backup giornalieri, settimanali e mensili
+
+## Risoluzione dei problemi
+
+Se riscontri problemi, controlla [Risoluzione dei problemi](/l/it/developers/self-host/capabilities/troubleshooting) per le soluzioni.
+
+## Hosting gestito
+
+<Tip>
+  Preferisci non gestire e mantenere Twenty in autonomia? [Trova un partner Twenty certificato](https://twenty.com/partners/list?categories=HOSTING\&ref=docs-docker-compose) per distribuire, ospitare e gestire la tua istanza end-to-end. *(Oppure contatta il nostro team: [contact@twenty.com](mailto:contact@twenty.com).)*
+</Tip>

packages/twenty-docs/l/it/developers/self-host/capabilities/key-rotation.mdx

@@ -0,0 +1,60 @@
+---
+title: Rotazione delle chiavi
+icon: rotate
+---
+
+Twenty ha due famiglie di chiavi indipendenti:
+
+* **Chiavi di firma JWT** — coppie di chiavi asimmetriche ES256 (con tag `kid`) archiviate in `core."signingKey"`, utilizzate per firmare e verificare i token di accesso / aggiornamento.
+* **Chiave di crittografia a riposo** — `ENCRYPTION_KEY`, utilizzata per crittografare token OAuth, variabili dell'applicazione, chiavi private delle chiavi di firma, valori di configurazione sensibili e segreti TOTP all'interno di un involucro `enc:v2:`.
+
+`APP_SECRET` è un segreto legacy mantenuto per compatibilità con le versioni precedenti: quando `ENCRYPTION_KEY` non è impostata funge da fallback per la crittografia a riposo / cookie di sessione e continua a verificare i token di accesso HS256 preesistenti. Sarà deprecata.
+
+## Chiavi di firma JWT
+
+Ogni chiave contiene una `publicKey` (mantenuta indefinitamente così da poter verificare i token emessi in precedenza), una `privateKey` crittografata (utilizzata solo mentre la chiave è quella corrente), un flag `isCurrent` (esattamente una riga alla volta) e un campo `revokedAt` opzionale.
+
+### Ruotare la chiave corrente
+
+Imposta `SIGNING_KEY_ROTATION_DAYS` per aderire: un cron giornaliero emette quindi una nuova chiave corrente quando quella esistente è più vecchia di tale soglia. Le chiavi precedenti *non* vengono revocate, quindi i token firmati con esse continuano a essere verificati. Lascia la variabile non impostata per disattivare la rotazione automatica.
+
+<Note>La rotazione automatica è disponibile a partire dalla versione v2.6+.</Note>
+
+### Revocare una chiave (solo in caso di fuga di dati / emergenza)
+
+**Settings → Admin Panel → Signing keys → Revoke** su una riga non corrente. Cancella il materiale privato crittografato, imposta `revokedAt` e rifiuta ogni token esistente firmato con quel `kid`.
+
+## Ruotare `ENCRYPTION_KEY`
+
+<Note>Il comando `secret-encryption:rotate` descritto di seguito è disponibile dalla v2.6+.</Note>
+
+Ogni valore crittografato è incapsulato come `enc:v2:\<keyId>:\<payload>`, dove `\<keyId>` è un prefisso esadecimale a 8 caratteri derivato dalla chiave grezza. La rotazione è online e riprendibile.
+
+1. **Generare una nuova chiave**: `openssl rand -base64 32`.
+
+2. **Configurare entrambe le chiavi affiancate** in `.env`, quindi riavviare:
+   ```ini
+   ENCRYPTION_KEY=NEW_VALUE
+   FALLBACK_ENCRYPTION_KEY=OLD_VALUE
+   ```
+   Le nuove scritture usano la nuova chiave, le righe esistenti vengono ancora decrittate tramite il fallback.
+
+3. **Ricrittografare le righe esistenti**:
+
+   ```bash
+   docker exec -it {server_container} yarn command:prod secret-encryption:rotate
+   ```
+
+   Il comando passa in rassegna sei sezioni (`connected-account-tokens`, `application-variable`, `application-registration-variable`, `signing-key-private-keys`, `sensitive-config-storage`, `totp-secrets`). Un filtro SQL salta le righe già con il nuovo `\<keyId>`, quindi il comando è idempotente: interrompi e riesegui secondo necessità. Esce con codice diverso da zero se una qualsiasi riga fallisce — riesegui per riprovare.
+
+   | Opzione                                  | Descrizione                                                 |
+   | ---------------------------------------- | ----------------------------------------------------------- |
+   | `-s, --site \<site>`    | Limita a un singolo sito.                                   |
+   | `-b, --batch-size \<n>` | Righe per batch (predefinito `200`, massimo `5000`).        |
+   | `-d, --dry-run`                          | Decrittografa + ricrittografa in memoria, salta l'`UPDATE`. |
+
+4. **Eliminare il fallback** una volta che `--dry-run` mostra zero righe rimanenti: rimuovere `FALLBACK_ENCRYPTION_KEY` e riavviare.
+
+## Supporto legacy per `APP_SECRET`
+
+Le istanze meno recenti che non hanno mai impostato `ENCRYPTION_KEY` usano `APP_SECRET` come chiave di crittografia a riposo (e come segreto del cookie di sessione, derivato da essa). Questo percorso è mantenuto per compatibilità con le versioni precedenti ma è **deprecato** — imposta una `ENCRYPTION_KEY` dedicata e segui la procedura di rotazione sopra per migrare. `APP_SECRET` continua a essere utilizzata per verificare i token di accesso HS256 legacy.

packages/twenty-docs/l/it/developers/self-host/capabilities/setup.mdx

@@ -0,0 +1,414 @@
+---
+title: Impostazione
+icon: gear
+---
+
+# Gestione della Configurazione
+
+<Warning>
+**Prima volta che installi?** Segui la [guida all'installazione di Docker Compose](/l/it/developers/self-host/capabilities/docker-compose) per far funzionare Twenty, quindi torna qui per la configurazione.
+</Warning>
+
+Twenty offre **due modalità di configurazione** per soddisfare diverse esigenze di distribuzione:
+
+**Accesso al pannello di amministrazione:** Solo gli utenti con privilegi di amministrazione (`canAccessFullAdminPanel: true`) possono accedere all'interfaccia di configurazione.
+
+## 1. Configurazione del Pannello di Amministrazione (Predefinito)
+
+```bash
+IS_CONFIG_VARIABLES_IN_DB_ENABLED=true  # default
+```
+
+**La maggior parte della configurazione avviene tramite l'interfaccia utente** dopo l'installazione:
+
+1. Accedi alla tua istanza Twenty (solitamente `http://localhost:3000`)
+2. Vai a **Impostazioni / Pannello di Amministrazione / Variabili di Configurazione**
+3. Configura integrazioni, email, storage e altro
+4. Le modifiche hanno effetto immediato (entro 15 secondi per distribuzioni multi-container)
+
+<Warning>
+**Distribuzioni Multi-Container:** Quando si utilizza la configurazione del database (`IS_CONFIG_VARIABLES_IN_DB_ENABLED=true`), sia i container server che worker leggono dallo stesso database. Le modifiche al pannello di amministrazione influiscono su entrambi automaticamente, eliminando la necessità di duplicare le variabili di ambiente tra i container (eccetto per le variabili infrastrutturali).
+</Warning>
+
+**Cosa puoi configurare tramite il pannello di amministrazione:**
+
+* **Autenticazione** - Google/Microsoft OAuth, impostazioni della password
+* **Email** - Impostazioni SMTP, modelli, verifica
+* **Storage** - Configurazione S3, percorsi storage locale
+* **Integrazioni** - Gmail, Google Calendar, servizi Microsoft
+* **Workflow e limitazione della frequenza** - Limiti di esecuzione, throttling delle API
+* **E molto altro ancora...**
+
+![Variabili di Configurazione del Pannello di Amministrazione](/images/user-guide/setup/admin-panel-config-variables.png)
+
+<Warning>
+Ogni variabile è documentata con descrizioni nel tuo pannello di amministrazione in **Impostazioni → Pannello di Amministrazione → Variabili di Configurazione**.
+Alcune impostazioni infrastrutturali come connessioni al database (`PG_DATABASE_URL`), URL del server (`SERVER_URL`) e segreti (`ENCRYPTION_KEY`, `FALLBACK_ENCRYPTION_KEY`) possono essere configurate solo tramite file `.env`.
+
+[Riferimento tecnico completo →](https://github.com/twentyhq/twenty/blob/main/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts)
+</Warning>
+
+## Chiavi di crittografia
+
+Twenty utilizza due chiavi di crittografia disponibili solo tramite variabili d'ambiente:
+
+| Variabile                 | Scopo                                                                                                                                                                                               | Obbligatorio                                                                                                         |
+| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `ENCRYPTION_KEY`          | Chiave primaria utilizzata per crittografare i segreti a riposo (token OAuth, variabili dell'applicazione, chiavi private delle chiavi di firma, segreti TOTP, valori di configurazione sensibili). | Sì per le nuove installazioni (le installazioni legacy possono invece fare affidamento su `APP_SECRET` — vedi sotto) |
+| `FALLBACK_ENCRYPTION_KEY` | Chiave utilizzata solo per la verifica. Impostata durante una rotazione alla *precedente* `ENCRYPTION_KEY` in modo che le righe esistenti rimangano decifrabili.                                    | Solo durante la rotazione                                                                                            |
+
+Per garantire la retrocompatibilità, se `ENCRYPTION_KEY` non è impostata, Twenty torna a utilizzare `APP_SECRET` per la crittografia a riposo, in modo da rispecchiare il comportamento legacy delle distribuzioni meno recenti. Le nuove installazioni dovrebbero sempre impostare una `ENCRYPTION_KEY` dedicata.
+
+Genera i valori con `openssl rand -base64 32` e conservali in un luogo sicuro (un secrets manager, configurazioni sigillate, ecc.). Perdere `ENCRYPTION_KEY` significa perdere l'accesso a ogni segreto memorizzato nel database.
+
+Per ruotare `ENCRYPTION_KEY` senza tempi di inattività, consulta la [guida alla rotazione delle chiavi](/l/it/developers/self-host/capabilities/key-rotation).
+
+## 2. Configurazione Solo-Ambiente
+
+```bash
+IS_CONFIG_VARIABLES_IN_DB_ENABLED=false
+```
+
+**Tutta la configurazione gestita tramite file `.env`:**
+
+1. Imposta `IS_CONFIG_VARIABLES_IN_DB_ENABLED=false` nel tuo file `.env`
+2. Aggiungi tutte le variabili di configurazione nel tuo file `.env`
+3. Riavvia i container per applicare le modifiche
+4. Il pannello di amministrazione mostrerà i valori attuali ma non potrà modificarli
+
+## Modalità multi-workspace
+
+Per impostazione predefinita, Twenty viene eseguito in **modalità a workspace singolo** — ideale per la maggior parte delle distribuzioni self-hosted in cui è necessaria un'istanza di CRM per la tua organizzazione.
+
+### Modalità a workspace singolo (predefinita)
+
+```bash
+IS_MULTIWORKSPACE_ENABLED=false  # default
+```
+
+* Un workspace per istanza di Twenty
+* Il primo utente diventa automaticamente amministratore con privilegi completi (`canImpersonate` e `canAccessFullAdminPanel`)
+* Le nuove registrazioni sono disabilitate dopo la creazione del primo workspace
+* Struttura URL semplice: `https://your-domain.com`
+
+### Abilitare la modalità multi-workspace
+
+```bash
+IS_MULTIWORKSPACE_ENABLED=true
+DEFAULT_SUBDOMAIN=app  # default value
+```
+
+Abilita la modalità multi-workspace per distribuzioni in stile SaaS in cui più team indipendenti necessitano dei propri workspace sulla stessa istanza di Twenty.
+
+**Differenze principali rispetto alla modalità a workspace singolo:**
+
+* È possibile creare più workspace sulla stessa istanza
+* Ogni workspace ottiene il proprio sottodominio (ad es., `sales.your-domain.com`, `marketing.your-domain.com`)
+* Gli utenti si registrano e accedono su `{DEFAULT_SUBDOMAIN}.your-domain.com` (ad es., `app.your-domain.com`)
+* Nessun privilegio amministrativo automatico — il primo utente in ogni workspace è un utente normale
+* Le impostazioni specifiche del workspace, come sottodominio e dominio personalizzato, diventano disponibili nelle impostazioni del workspace
+
+<Warning>
+**Impostazione solo per l'ambiente:** `IS_MULTIWORKSPACE_ENABLED` può essere configurata solo tramite il file `.env` e richiede un riavvio. Non può essere modificata tramite il pannello di amministrazione.
+</Warning>
+
+### Configurazione DNS per la modalità multi-workspace
+
+Quando si utilizza la modalità multi-workspace, configura il DNS con un record wildcard per consentire la creazione dinamica dei sottodomini:
+
+```
+*.your-domain.com -> your-server-ip
+```
+
+Ciò abilita l'instradamento automatico dei sottodomini per i nuovi workspace senza configurazione DNS manuale.
+
+### Limitare la creazione di workspace
+
+In modalità multi-workspace, potresti voler limitare chi può creare nuovi workspace:
+
+```bash
+IS_WORKSPACE_CREATION_LIMITED_TO_SERVER_ADMINS=true
+```
+
+Quando è abilitata, solo gli utenti con `canAccessFullAdminPanel` possono creare workspace aggiuntivi. Gli utenti possono comunque creare il loro primo workspace durante la registrazione iniziale.
+
+## Integrazione Gmail & Google Calendar
+
+### Crea Progetto nel Google Cloud
+
+1. Vai a [Google Cloud Console](https://console.cloud.google.com/)
+2. Crea un nuovo progetto o seleziona uno esistente
+3. Abilita queste API:
+
+* [API Gmail](https://console.cloud.google.com/apis/library/gmail.googleapis.com)
+* [API Google Calendar](https://console.cloud.google.com/apis/library/calendar-json.googleapis.com)
+* [API People](https://console.cloud.google.com/apis/library/people.googleapis.com)
+
+### Configura OAuth
+
+1. Vai a [Credenziali](https://console.cloud.google.com/apis/credentials)
+2. Crea ID client OAuth 2.0
+3. Aggiungi questi URI di reindirizzamento:
+   * `https://{your-domain}/auth/google/redirect` (per SSO)
+   * `https://{your-domain}/auth/google-apis/get-access-token` (per integrazioni)
+
+### Configura in Twenty
+
+1. Vai a **Impostazioni → Pannello di Amministrazione → Variabili di Configurazione**
+2. Trova la sezione **Google Auth**
+3. Imposta queste variabili:
+   * `MESSAGING_PROVIDER_GMAIL_ENABLED=true`
+   * `CALENDAR_PROVIDER_GOOGLE_ENABLED=true`
+   * `AUTH_GOOGLE_CLIENT_ID={client-id}`
+   * `AUTH_GOOGLE_CLIENT_SECRET={client-secret}`
+   * `AUTH_GOOGLE_CALLBACK_URL=https://{your-domain}/auth/google/redirect`
+   * `AUTH_GOOGLE_APIS_CALLBACK_URL=https://{your-domain}/auth/google-apis/get-access-token`
+
+<Warning>
+**Modalità solo ambiente:** Se imposti `IS_CONFIG_VARIABLES_IN_DB_ENABLED=false`, aggiungi queste variabili al tuo file `.env` invece.
+</Warning>
+
+**Scope richiesti** (configurati automaticamente): [Vedi il codice sorgente pertinente](https://github.com/twentyhq/twenty/blob/main/packages/twenty-server/src/engine/core-modules/auth/utils/get-google-apis-oauth-scopes.ts#L4-L10)
+
+* `https://www.googleapis.com/auth/calendar.events`
+* `https://www.googleapis.com/auth/gmail.readonly`
+* `https://www.googleapis.com/auth/profile.emails.read`
+
+### Se la tua app è in modalità di test
+
+Se la tua app è in modalità di test, dovrai aggiungere utenti di prova al tuo progetto.
+
+Sotto [Schermo di Consenso OAuth](https://console.cloud.google.com/apis/credentials/consent), aggiungi i tuoi utenti di prova nella sezione "Utenti di Prova".
+
+## Integrazione Microsoft 365
+
+<Warning>
+Gli utenti devono avere una [Licenza Microsoft 365](https://admin.microsoft.com/Adminportal/Home) per poter utilizzare l'API Calendario e Messaggi. Non potranno sincronizzare il loro account su Twenty senza una.
+</Warning>
+
+### Crea un progetto in Microsoft Azure
+
+Avrai bisogno di creare un progetto in [Microsoft Azure](https://portal.azure.com/#view/Microsoft_AAD_IAM/AppGalleryBladeV2) e ottenere le credenziali.
+
+### Abilita API
+
+Nel Microsoft Azure Console abilita le seguenti API in "Permessi":
+
+* Microsoft Graph: Mail.ReadWrite
+* Microsoft Graph: Mail.Send
+* Microsoft Graph: Calendars.Read
+* Microsoft Graph: User.Read
+* Microsoft Graph: openid
+* Microsoft Graph: email
+* Microsoft Graph: profile
+* Microsoft Graph: offline_access
+
+<Note>
+"Mail.ReadWrite" e "Mail.Send" sono obbligatori solo se vuoi inviare email utilizzando le nostre azioni di flusso di lavoro. Puoi usare "Mail.Read" invece se vuoi solo ricevere email.
+</Note>
+
+<Note>
+"Calendars.ReadWrite" è obbligatorio se vuoi creare eventi del calendario utilizzando le nostre azioni di flusso di lavoro. Se vuoi solo sincronizzare gli eventi del calendario, usa "Calendars.Read".
+</Note>
+
+### URI di Riindirizzamento Autorizzati
+
+Devi aggiungere i seguenti URI di reindirizzamento al tuo progetto:
+
+* `https://{your-domain}/auth/microsoft/redirect` se vuoi usare Microsoft SSO
+* `https://{your-domain}/auth/microsoft-apis/get-access-token`
+
+### Configura in Twenty
+
+1. Vai a **Impostazioni → Pannello di Amministrazione → Variabili di Configurazione**
+2. Trova la sezione **Microsoft Auth**
+3. Imposta queste variabili:
+   * `MESSAGING_PROVIDER_MICROSOFT_ENABLED=true`
+   * `CALENDAR_PROVIDER_MICROSOFT_ENABLED=true`
+   * `AUTH_MICROSOFT_ENABLED=true`
+   * `AUTH_MICROSOFT_CLIENT_ID={client-id}`
+   * `AUTH_MICROSOFT_CLIENT_SECRET={client-secret}`
+   * `AUTH_MICROSOFT_CALLBACK_URL=https://{your-domain}/auth/microsoft/redirect`
+   * `AUTH_MICROSOFT_APIS_CALLBACK_URL=https://{your-domain}/auth/microsoft-apis/get-access-token`
+
+<Warning>
+**Modalità solo ambiente:** Se imposti `IS_CONFIG_VARIABLES_IN_DB_ENABLED=false`, aggiungi queste variabili al tuo file `.env` invece.
+</Warning>
+
+### Configura scope
+
+[Vedi il codice sorgente pertinente](https://github.com/twentyhq/twenty/blob/main/packages/twenty-server/src/engine/core-modules/auth/utils/get-microsoft-apis-oauth-scopes.ts#L2-L9)
+
+* 'openid'
+* 'email'
+* 'profilo'
+* 'offline_access'
+* 'Mail.ReadWrite'
+* 'Mail.Send'
+* 'Calendars.Read'
+
+### Se la tua app è in modalità di test
+
+Se la tua app è in modalità di test, dovrai aggiungere utenti di prova al tuo progetto.
+
+Aggiungi i tuoi utenti di prova nella sezione "Utenti e gruppi".
+
+## Lavori in Background per Calendario & Messaggistica
+
+Dopo aver configurato le integrazioni di Gmail, Google Calendar o Microsoft 365, devi avviare i lavori in background che sincronizzano i dati.
+
+Registrare i seguenti lavori ricorrenti nel tuo container worker:
+
+```bash
+# from your worker container
+yarn command:prod cron:messaging:messages-import
+yarn command:prod cron:messaging:message-list-fetch
+yarn command:prod cron:calendar:calendar-event-list-fetch
+yarn command:prod cron:calendar:calendar-events-import
+yarn command:prod cron:messaging:ongoing-stale
+yarn command:prod cron:calendar:ongoing-stale
+yarn command:prod cron:workflow:automated-cron-trigger
+```
+
+## Configurazione Email
+
+1. Vai a **Impostazioni → Pannello di Amministrazione → Variabili di Configurazione**
+2. Trova la sezione **Email**
+3. Configura le impostazioni SMTP:
+
+<Tabs>
+
+  <Tab title="Gmail">
+
+  Avrai bisogno di provvedere una [Password per l'App](https://support.google.com/accounts/answer/185833).
+  * EMAIL_DRIVER=smtp
+  * EMAIL_SMTP_HOST=smtp.gmail.com
+  * EMAIL_SMTP_PORT=465
+  * EMAIL_SMTP_USER=indirizzo_email_gmail
+  * EMAIL_SMTP_PASSWORD='password_app_gmail'
+
+  </Tab>
+
+  <Tab title="Office365">
+
+  Tieni a mente che se hai abilitato l'autenticazione a due fattori, avrai bisogno di fornire una [Password per l'App](https://support.microsoft.com/en-us/account-billing/manage-app-passwords-for-two-step-verification-d6dc8c6d-4bf7-4851-ad95-6d07799387e9).
+  * EMAIL_DRIVER=smtp
+  * EMAIL_SMTP_HOST=smtp.office365.com
+  * EMAIL_SMTP_PORT=587
+  * EMAIL_SMTP_USER=indirizzo_email_office365
+  * EMAIL_SMTP_PASSWORD='password_office365'
+
+  </Tab>
+
+  <Tab title="smtp4dev">
+
+  **smtp4dev** è un server SMTP fittizio per lo sviluppo e il test.
+  * Esegui l'immagine smtp4dev: `docker run --rm -it -p 8090:80 -p 2525:25 rnwood/smtp4dev`
+  * Accedi all'interfaccia smtp4dev qui: [http://localhost:8090](http://localhost:8090)
+  * Imposta le seguenti variabili:
+    * EMAIL_DRIVER=smtp
+    * EMAIL_SMTP_HOST=localhost
+    * EMAIL_SMTP_PORT=2525
+
+  </Tab>
+
+</Tabs>
+
+<Warning>
+**Modalità solo ambiente:** Se imposti `IS_CONFIG_VARIABLES_IN_DB_ENABLED=false`, aggiungi queste variabili al tuo file `.env` invece.
+</Warning>
+
+## Archiviazione S3
+
+<Warning>
+Per impostazione predefinita, Twenty archivia i file caricati nel file system locale. Per le distribuzioni in produzione, usa S3 o un servizio compatibile con S3 (MinIO, DigitalOcean Spaces, ecc.). per garantire che i file persistano tra i riavvii dei container e per poter scalare su più istanze server.
+</Warning>
+
+Imposta `STORAGE_TYPE=S_3` e configura le variabili `STORAGE_S3_*` tramite il pannello di amministrazione o `.env`. Consulta il [riferimento a config-variables.ts](https://github.com/twentyhq/twenty/blob/main/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts) per l'elenco completo delle variabili S3.
+
+Quando si usa S3 con funzionalità che dipendono da CORS (ad esempio i download di file nel browser), assicurati che il tuo bucket consenta l'origine del tuo frontend di Twenty nella sua configurazione CORS.
+
+## Funzioni logiche & interprete del codice
+
+Twenty supporta le funzioni logiche per i workflow e l'interprete del codice per l'analisi dei dati con IA. Entrambi eseguono codice fornito dall'utente e richiedono una configurazione esplicita per motivi di sicurezza.
+
+### Impostazioni di sicurezza predefinite
+
+**In produzione (NODE_ENV=production):** Sia le funzioni logiche sia l'interprete del codice hanno come impostazione predefinita **Disabilitato**. È necessario abilitarli esplicitamente con `LOGIC_FUNCTION_TYPE` e `CODE_INTERPRETER_TYPE` se queste funzionalità sono necessarie.
+
+**In sviluppo (NODE_ENV=development):** Entrambi sono impostati su **LOCAL** per comodità quando vengono eseguiti in locale.
+
+<Warning>
+**Avviso di sicurezza:** Il driver locale (`LOGIC_FUNCTION_TYPE=LOCAL` o `CODE_INTERPRETER_TYPE=LOCAL`) esegue il codice direttamente sull'host in un processo Node.js senza sandboxing. Dovrebbe essere utilizzato solo per codice attendibile in fase di sviluppo. Per le distribuzioni in produzione che gestiscono codice non affidabile, usa `LOGIC_FUNCTION_TYPE=LAMBDA` o `CODE_INTERPRETER_TYPE=E2B` (con sandboxing), oppure lasciali disabilitati.
+</Warning>
+
+### Funzioni logiche - Driver disponibili
+
+| Driver       | Variabile di ambiente          | Caso d'uso                                   | Livello di sicurezza                 |
+| ------------ | ------------------------------ | -------------------------------------------- | ------------------------------------ |
+| Disabilitato | `LOGIC_FUNCTION_TYPE=DISABLED` | Disabilita completamente le funzioni logiche | N/A                                  |
+| Locale       | `LOGIC_FUNCTION_TYPE=LOCAL`    | Ambienti di sviluppo e attendibili           | Basso (nessuna sandbox)              |
+| Lambda       | `LOGIC_FUNCTION_TYPE=LAMBDA`   | Produzione con codice non attendibile        | Alto (isolamento a livello hardware) |
+
+### Funzioni logiche - Configurazione consigliata
+
+**Per lo sviluppo:**
+
+```bash
+LOGIC_FUNCTION_TYPE=LOCAL  # default when NODE_ENV=development
+```
+
+**Per la produzione (AWS):**
+
+```bash
+LOGIC_FUNCTION_TYPE=LAMBDA
+LOGIC_FUNCTION_LAMBDA_REGION=us-east-1
+LOGIC_FUNCTION_LAMBDA_ROLE=arn:aws:iam::123456789:role/your-lambda-role
+LOGIC_FUNCTION_LAMBDA_ACCESS_KEY_ID=your-access-key
+LOGIC_FUNCTION_LAMBDA_SECRET_ACCESS_KEY=your-secret-key
+```
+
+**Per disabilitare le funzioni logiche:**
+
+```bash
+LOGIC_FUNCTION_TYPE=DISABLED  # default when NODE_ENV=production
+```
+
+### Interprete del codice - Driver disponibili
+
+| Driver       | Variabile di ambiente            | Caso d'uso                            | Livello di sicurezza    |
+| ------------ | -------------------------------- | ------------------------------------- | ----------------------- |
+| Disabilitato | `CODE_INTERPRETER_TYPE=DISABLED` | Disabilita l'esecuzione del codice IA | N/A                     |
+| Locale       | `CODE_INTERPRETER_TYPE=LOCAL`    | Solo per lo sviluppo                  | Basso (nessuna sandbox) |
+| E2B          | `CODE_INTERPRETER_TYPE=E_2_B`    | Produzione con esecuzione in sandbox  | Alta (sandbox isolata)  |
+
+<Note>
+Quando si utilizza `LOGIC_FUNCTION_TYPE=DISABLED` o `CODE_INTERPRETER_TYPE=DISABLED`, qualsiasi tentativo di esecuzione restituirà un errore. Ciò è utile se si desidera eseguire Twenty senza queste funzionalità.
+</Note>
+
+## API e front-end su host separati
+
+Rilevante solo se il back-end non serve il front-end. Le distribuzioni con la stessa origine
+non richiedono nulla qui.
+
+Dichiara tutte le origini del browser che comunicano con l'API, separate da virgole. `SERVER_URL`
+e `FRONTEND_URL` sono già considerate attendibili. Il server registra un avviso quando un browser
+lo chiama da origine non dichiarata.
+
+```bash
+AUTH_COOKIE_ALLOWED_ORIGINS=https://app.example.com
+```
+
+<Warning>
+Il front-end invia le credenziali su ogni richiesta, e i browser rifiutano una risposta credenziale
+da un'origine non dichiarata, quindi l'applicazione non riesce a caricare fino a quando
+hai impostato questo.
+</Warning>
+
+Se i due host si trovano su domini registrabili diversi (non solo sottodomini
+diversi), imposta anche `AUTH_COOKIE_SAME_SITE=none`, che richiede HTTPS.
+
+Con multi-workspace abilitato, non elencare ogni sottodominio workspace qui.
+Invece, percorsi percorsi API (`/graphql`, `/metadata`, `/rest`, `/auth/`,
+`/client-config`, `/file`) al back-end su ogni hostname di workspace, quindi ogni workspace
+rimane la stessa origine — così funziona Twenty Cloud.

packages/twenty-docs/l/it/developers/self-host/capabilities/troubleshooting.mdx

@@ -0,0 +1,255 @@
+---
+title: Risoluzione dei problemi
+icon: wrench
+---
+
+## Risoluzione dei problemi
+
+Se riscontri qualche problema durante l'impostazione dell'ambiente per lo sviluppo, l'aggiornamento della tua istanza o l'auto-hosting,
+qui sono alcune soluzioni per problemi comuni.
+
+### Auto-ospitato
+
+#### La prima installazione risulta in `autenticazione password fallita per l'utente "postgres"`
+
+🚨 **IMPORTANTE: Questa soluzione è SOLO per nuove installazioni** 🚨
+Se hai un'istanza di Twenty esistente con dati di produzione, **NON** seguire questi passaggi poiché elimineranno permanentemente il tuo database!
+
+Durante l'installazione di Twenty per la prima volta, potresti voler cambiare la password del database predefinita.
+La password impostata durante la prima installazione viene memorizzata in modo permanente nel volume del database. Se in seguito provi a cambiare questa password nella configurazione senza rimuovere il vecchio volume, otterrai errori di autenticazione poiché il database utilizza ancora la password iniziale.
+
+⚠️ ATTENZIONE: I passaggi seguenti ELIMINERANNO PERMANENTEMENTE tutti i dati del database! ⚠️
+Procedi solo se si tratta di una nuova installazione senza dati importanti.
+
+Per aggiornare il file `PG_DATABASE_PASSWORD`, è necessario:
+
+```sh
+# Update the PG_DATABASE_PASSWORD in .env
+docker compose down --volumes
+docker compose up -d
+```
+
+#### CR interruzioni di linea trovate [Windows]
+
+Questo accade a causa di caratteri Windows line-ending combinati con la configurazione di Git. Prova a eseguire:
+
+```
+git config --global core.autocrlf false
+```
+
+Quindi elimina il repository e clonalo nuovamente.
+
+#### Schema dei metadati mancante
+
+Durante l'installazione di Twenty, devi fornire il tuo database postgres con gli schemi, le estensioni e gli utenti corretti.
+Se riesci a eseguire correttamente questo provisioning, dovresti avere schemi `default` e `metadata` nel tuo database.
+Se non lo fai, assicurati di non avere più di un'istanza PostgreSQL in esecuzione sul tuo computer.
+
+#### Impossibile trovare il modulo 'twenty-emails' o le relative dichiarazioni di tipo corrispondente.
+
+Devi costruire il pacchetto `twenty-emails` (`npx nx run twenty-emails:build`) prima di eseguire l'inizializzazione del database.
+
+#### Pacchetto twenty-x mancante
+
+Assicurati di eseguire yarn nella directory principale e poi esegui `npx nx server:dev twenty-server`. Se ancora non funziona prova a costruire manualmente il pacchetto mancante.
+
+#### Lint su Salva non funzionante
+
+Questo dovrebbe funzionare direttamente con l'estensione Oxc (`oxc.oxc-vscode`) installata. Se questo non funziona, prova ad aggiungerlo alle impostazioni del codice VS (campo di applicazione del contenitore dev):
+
+```
+"editor.codeActionsOnSave": {
+
+  "source.fixAll.oxc": "explicit"
+
+}
+```
+
+#### Durante l'esecuzione di `npx nx start` o `npx nx start twenty-front`, viene generato un errore fuori memoria
+
+Esegui solo i servizi di cui hai bisogno, invece di `npx nx start`. Ad esempio, se lavori sul server, esegui solo `npx nx worker twenty-server`
+
+**Se non funziona:**
+Se hai provato ad eseguire solo `npx nx run twenty-server:start` su WSL e sta fallendo con l'errore di memoria sottostante:
+
+`ERRORE FATALE: Mark-compacts inefficaci vicino al limite dell'heap Assegnazione fallita - heap di memoria JavaScript esaurito`
+
+Un workaround è quello di eseguire il seguente comando nel tuo terminale, o aggiungerlo al tuo profilo `.bashrc` in modo che sia applicato automaticamente:
+
+`export NODE_OPTIONS="--max-old-space-size=8192"`
+
+Il flag --max-old-space-size=8192 imposta un limite massimo di 8GB per l'heap di Node.js; l'utilizzo si adatta alla domanda dell'applicazione.
+Riferimento: https://stackoverflow.com/questions/56982005/where-do-i-set-node-options-max-old-space-size-2048
+
+**Se non funziona:**
+Verifica quali processi stanno occupando la maggior parte della RAM della tua macchina. A Venti, abbiamo notato alcune estensioni del codice VS stavano prendendo un sacco di RAM, quindi abbiamo temporaneamente disabilitato loro.
+
+**Se non funziona:**
+Il riavvio della macchina aiuta a ripulire i processi fantasma.
+
+#### Durante l'esecuzione di `npx nx start` ci sono strani [0] e [1] nei log
+
+È previsto poiché il comando `npx nx start` sta eseguendo più comandi in background
+
+#### Nessuna email inviata
+
+La maggior parte delle volte, è perché il `worker` non è in esecuzione in background. Prova a eseguire
+
+```
+npx nx worker twenty-server
+```
+
+#### Impossibile collegare il mio account Microsoft 365 a Twenty
+
+La maggior parte delle volte, è perché il tuo amministratore non ha abilitato la Licenza Microsoft 365 per il tuo account. Controlla [https://admin.microsoft.com/](https://admin.microsoft.com/Adminportal/Home).
+
+Se hai un codice di errore `AADSTS50020`, probabilmente significa che stai utilizzando un account Microsoft personale. Questo non è ancora supportato. Maggiori informazioni [qui](https://learn.microsoft.com/fr-fr/troubleshoot/entra/entra-id/app-integration/error-code-aadsts50020-user-account-identity-provider-does-not-exist)
+
+#### Durante l'esecuzione `yarn`, gli avvisi appaiono nella console
+
+Gli avvisi informano sul caricamento di dipendenze aggiuntive che non sono esplicitamente dichiarate in `package.json`, quindi fintanto che non appare un errore critico, tutto dovrebbe funzionare come previsto.
+
+#### Quando un utente accede alla pagina di login, viene visualizzato un errore su un utente non autorizzato che tenta di accedere a un workspace nei registri
+
+Questo è atteso come l'utente non è autorizzato quando si è disconnesso, dal momento che la loro identità non è stata verificata.
+
+#### Come verificare se il tuo worker è in esecuzione?
+
+* Vai su [webhook-test.com](https://webhook-test.com/) e copia **Your Unique Webhook URL**.
+
+<div style={{textAlign: 'center'}}>
+  <img src="/images/docs/developers/self-hosting/webhook-test.jpg" alt="Test webhook" />
+</div>
+
+* Apri la tua app Twenty, naviga su `/settings` e abilita il toggle **Avanzate** in basso a sinistra dello schermo.
+* Crea un nuovo webhook.
+* Incolla **Your Unique Webhook URL** nel campo **Endpoint Url** in Twenty. Imposta i **Filtri** su `Companies` e `Created`.
+
+<div style={{textAlign: 'center'}}>
+  <img src="/images/docs/developers/self-hosting/webhook-settings.jpg" alt="Impostazioni webhook" />
+</div>
+
+* Vai su `/objects/companies` e crea un nuovo record aziendale.
+* Ritorna su [webhook-test.com](https://webhook-test.com/) e verifica se è stata ricevuta una nuova **richiesta POST**.
+
+<div style={{textAlign: 'center'}}>
+  <img src="/images/docs/developers/self-hosting/webhook-test-result.jpg" alt="Risultato del test webhook" />
+</div>
+
+* Se è ricevuta una **richiesta POST**, il tuo worker è in esecuzione con successo. In caso contrario, devi risolvere i problemi del tuo worker.
+
+#### Front-end non riesce ad avviare e restituisce l'errore TS5042: L'opzione 'project' non può essere miscelata con i file sorgente sulla riga di comando
+
+Commenta il plugin checker in `packages/twenty-ui/vite-config.ts`, come mostrato nell'esempio qui sotto:
+
+```
+plugins: [
+      react({ jsxImportSource: 'react' }),
+      tsconfigPaths(),
+      svgr(),
+      dts(dtsConfig),
+      // checker(checkersConfig),
+      wyw({
+        include: [
+          '**/OverflowingTextWithTooltip.tsx',
+          '**/Chip.tsx',
+          '**/Tag.tsx',
+          '**/Avatar.tsx',
+          '**/AvatarChip.tsx',
+        ],
+        babelOptions: {
+          presets: ['@babel/preset-typescript', '@babel/preset-react'],
+        },
+      }),
+    ],
+```
+
+#### Pannello di amministrazione non accessibile
+
+Eseguire `UPDATE core."user" SET "canAccessFullAdminPanel" = VERO WHERE email = 'you@yourdomain.com';` nel contenitore del database per ottenere l'accesso al pannello di amministrazione.
+
+#### Durante l'esecuzione di un workflow, l'esecuzione del workflow non riesce con "L'esecuzione delle funzioni logiche è disabilitata. Imposta LOGIC_FUNCTION_TYPE su LOCAL o LAMBDA per abilitarle."
+
+In produzione, le funzioni logiche sono disabilitate per impostazione predefinita. Imposta la variabile d'ambiente `LOGIC_FUNCTION_TYPE` su `LOCAL` o `LAMBDA` per abilitarle. Questo può essere configurato tramite variabili d'ambiente o tramite le variabili del database del pannello di amministrazione. Consulta la [guida alla configurazione delle funzioni logiche](/l/it/developers/self-host/capabilities/setup#logic-functions-available-drivers) per dettagli.
+
+#### Quando digito un messaggio in chat AI, non risponde immediatamente e devo aggiornare la pagina per vedere la risposta
+
+Ciò significa che il tuo proxy inverso manca la configurazione per le risposte API basate su stream. Di seguito è riportato un esempio di configurazione Nginx:
+
+```
+location ~* ^/api/.*stream|\/graphql\/stream {
+proxy_pass http://twenty_backend;
+proxy_http_version 1.1;
+proxy_set_header Connection "";
+proxy_set_header Host $host;
+proxy_set_header X-Real-IP $remote_addr;
+proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+proxy_set_header X-Forwarded-Proto $scheme;
+proxy_buffering off;
+proxy_request_buffering off;
+proxy_cache off;
+gzip off;
+#chunked_transfer_encoding off;
+add_header X-Accel-Buffering no always;
+}
+```
+
+### 1-Clic Docker Componi
+
+#### Impossibile connettersi
+
+Se non riesci ad accedere dopo la configurazione:
+
+1. Esegui i seguenti comandi:
+   ```bash
+   docker exec -it twenty-server-1 yarn
+   docker exec -it twenty-server-1 npx nx database:reset  --configuration=no-seed
+   ```
+2. Riavvia i container Docker:
+   ```bash
+   docker compose down
+   docker compose up -d
+   ```
+
+Si noti che il comando `database:reset` cancellerà completamente il database e ricreerà da zero.
+
+#### Problemi di connessione dietro un reverse proxy
+
+Se stai eseguendo Twenty dietro un reverse proxy e stai riscontrando problemi di connessione:
+
+1. **Verifica SERVER_URL:**
+
+   Assicurati che il `SERVER_URL` nel tuo file `.env` corrisponda all'URL di accesso esterno, incluso `https` se SSL è abilitato.
+
+2. **Controlla le impostazioni del reverse proxy:**
+
+   * Conferma che il tuo reverse proxy sta inoltrando correttamente le richieste al server Twenty.
+   * Assicurati che le intestazioni come `X-Forwarded-For` e `X-Forwarded-Proto` siano impostate correttamente.
+
+3. **Riavvia i servizi:**
+
+   Dopo aver apportato modifiche, riavvia sia il reverse proxy che i container Twenty.
+
+#### Errore durante il caricamento di un'immagine - permesso negato
+
+Cambiare la proprietà della cartella dei dati sull'host da root a un altro utente e gruppo risolve questo problema.
+
+#### Errore 'File non trovato' durante il test della funzione Logic nel workflow
+
+Esegui il comando `yarn command:prod application:rebuild-default-deps` nel container twenty-server per risolvere il problema delle dipendenze mancanti.
+
+## Ottenere aiuto
+
+Se incontri problemi non coperti in questa guida:
+
+* Controlla i log:
+
+  Visualizza i log dei container per i messaggi di errore:
+
+  ```bash
+  docker compose logs
+  ```
+
+* Supporto comunitario:
+
+  Contatta la [comunità Twenty](https://github.com/twentyhq/twenty/issues) o [canali di supporto](https://discord.gg/cx5n4Jzs57) per assistenza.

packages/twenty-docs/l/it/developers/self-host/capabilities/upgrade-guide.mdx

@@ -0,0 +1,106 @@
+---
+title: Guida per l'aggiornamento
+icon: arrow-up-right-dots
+---
+
+## Linee guida generali
+
+**Esegui sempre un backup del database prima di iniziare la procedura di aggiornamento** eseguendo:
+
+```bash
+docker exec -it {db_container_name_or_id} pg_dumpall -U {postgres_user} > databases_backup.sql
+```
+
+Per ripristinare dal backup:
+
+```bash
+cat databases_backup.sql | docker exec -i {db_container_name_or_id} psql -U {postgres_user}
+```
+
+Se utilizzi Docker Compose, segui questi passaggi:
+
+1. Arresta Twenty: `docker compose down`
+2. Modifica il valore di `TAG` nel file `.env` nella stessa directory di `docker-compose.yml`
+3. Avvia Twenty: `docker compose up -d`
+
+All'avvio, il server esegue automaticamente tutte le migrazioni di aggiornamento necessarie. Non è necessario alcun comando manuale.
+
+## Aggiornamento alla v2.34+ — PostgreSQL 15 minimo
+
+Twenty v2.34 richiede PostgreSQL 15 o una versione successiva. La configurazione ufficiale di Docker Compose utilizza PostgreSQL 16. Se la tua istanza si connette a un database gestito esternamente, aggiornalo prima di avviare il server v2.34.
+
+## Aggiornamenti tra versioni (v1.23+)
+
+A partire da **v1.23**, Twenty supporta gli aggiornamenti tra versioni. Puoi passare direttamente da qualsiasi versione supportata all'ultima versione senza dover attraversare ogni versione intermedia.
+
+Ad esempio, l'aggiornamento da v1.23 direttamente a v2.0 è pienamente supportato.
+
+## Aggiornamento alla v2.5+ — envelope di crittografia dei dati a riposo
+
+A partire dalla **v2.5**, Twenty memorizza i segreti a riposo (token OAuth, variabili dell'applicazione, chiavi private di firma, valori di configurazione sensibili, segreti TOTP) all'interno di un envelope versionato `enc:v2:` crittografato con `ENCRYPTION_KEY` (o `APP_SECRET` se `ENCRYPTION_KEY` non è impostata).
+
+Il primo avvio su v2.5 esegue comandi di aggiornamento lenti che popolano retroattivamente le righe esistenti nel nuovo envelope. Sono idempotenti — se si interrompe e si riavvia il server, riprende da dove si era interrotto — ma possono richiedere tempo su database di grandi dimensioni. Puoi monitorare l'avanzamento con `upgrade:status`.
+
+Dovresti impostare un `ENCRYPTION_KEY` dedicato **prima** dell'aggiornamento a v2.5, in modo che il popolamento retroattivo scriva fin dall'inizio le righe sotto tale chiave. Cambiare chiave dopo il popolamento retroattivo richiede una [rotazione](/l/it/developers/self-host/capabilities/key-rotation).
+
+## Rotazione di segreti e chiavi di firma
+
+Per le attività operative quotidiane come ruotare `ENCRYPTION_KEY`, ruotare la chiave di firma JWT o revocare una chiave di firma compromessa, vedi la [Guida alla rotazione delle chiavi](/l/it/developers/self-host/capabilities/key-rotation) dedicata.
+
+## Verifica dello stato dell'aggiornamento
+
+Il comando `upgrade:status` consente di ispezionare lo stato corrente della tua istanza e delle migrazioni degli spazi di lavoro. È utile per eseguire il debug di problemi di aggiornamento o quando si apre una richiesta di assistenza.
+
+Eseguilo dal container del server:
+
+```bash
+docker exec -it {server_container_name_or_id} yarn command:prod upgrade:status
+```
+
+Esempio di output:
+
+```sh
+APP_VERSION: v1.23.0
+
+Instance
+    Inferred version: 1.23.0
+    Latest command:   1.23.0_DropWorkspaceVersionColumnFastInstanceCommand_1785000000000
+    Status:           Up to date
+    Executed by:      v1.23.0
+    At:               2026-04-16T11:43:58.823Z
+
+Workspace
+  Apple (20202020-1c25-4d02-bf25-6aeccf7ea419)
+      Inferred version: 1.23.0
+      Latest command:   1.23.0_UpdateGlobalObjectContextCommandMenuItemsCommand_1780000005000
+      Status:           Up to date
+      Executed by:      v1.23.0
+      At:               2026-04-16T11:44:09.361Z
+
+Summary
+    Instance: Up to date
+    Workspaces: 1 up to date, 0 behind, 0 failed (1 total)
+```
+
+### Opzioni
+
+| Opzione                   | Descrizione                                                                                  |
+| ------------------------- | -------------------------------------------------------------------------------------------- |
+| `-w, --workspace-id <id>` | Filtra per uno specifico spazio di lavoro. Può essere passato più volte.                     |
+| `-f, --failed-only`       | Nasconde gli spazi di lavoro aggiornati; mostra solo quelli arretrati e quelli non riusciti. |
+
+## Risoluzione dei problemi
+
+Se l'aggiornamento non riesce su alcuni spazi di lavoro, il server non proseguirà oltre il passaggio in cui si è verificato l'errore. Riavviando il server (`docker compose up -d`), l'aggiornamento verrà riprovato dal punto in cui era stato interrotto.
+
+Per identificare rapidamente i problemi, esegui:
+
+```bash
+docker exec -it {server_container_name_or_id} yarn command:prod upgrade:status --failed-only
+```
+
+Mostra solo gli spazi di lavoro arretrati o non riusciti, insieme al messaggio di errore per ciascun errore.
+
+## Prima della v1.23
+
+Se la tua istanza è precedente alla v1.23, devi eseguire l'aggiornamento in modo incrementale attraverso ogni versione maggiore contrassegnata (da v1.6 a v1.7, poi da v1.7 a v1.8 e così via) fino a raggiungere la v1.23. Da lì, puoi passare direttamente all'ultima versione.

packages/twenty-docs/l/it/developers/self-host/self-host.mdx

@@ -0,0 +1,26 @@
+---
+title: Auto-ospitazione
+description: Distribuisci e gestisci Twenty sulla tua infrastruttura.
+---
+
+<Frame>
+  <img src="/images/user-guide/what-is-twenty/20.png" alt="AI" />
+</Frame>
+
+## Panoramica
+
+Twenty può essere auto-ospitato sulla tua infrastruttura, offrendoti il pieno controllo sui tuoi dati e sulla distribuzione.
+
+## Perché l'auto-ospitazione?
+
+* **Proprietà dei dati**: Conserva tutti i dati del CRM sui tuoi server
+* **Conformità**: Soddisfa i requisiti normativi sulla residenza dei dati
+* **Personalizzazione**: Accesso completo per modificare ed estendere la piattaforma
+
+## Per iniziare
+
+<CardGroup cols={2}>
+  <Card title="Docker Compose" icon="docker" href="/l/it/developers/self-host/capabilities/docker-compose">
+    Configurazione rapida con Docker
+  </Card>
+</CardGroup>