> ## Documentation Index
> Fetch the complete documentation index at: https://ayakaleaf-pro.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Configurare l'ambiente di sviluppo (locale)

> Configura il tuo ambiente di sviluppo sul tuo server locale o sul tuo computer desktop.

## Prerequisiti

Overleaf è un tipico progetto open source con architettura a microservizi, in cui tutti i servizi vengono eseguiti in Docker. 

* Il codice sorgente ufficiale della Community Edition si trova su [GitHub Overleaf Official](https://github.com/overleaf/overleaf/tree). 
* Il codice sorgente di Overleaf-CEP è disponibile su [GitHub Yu-i-i/Overleaf](https://github.com/yu-i-i/overleaf-cep).
* Overleaf Pro Edition è disponibile su [GitHub Ayaka-notes/overleaf-pro](https://github.com/ayaka-notes/overleaf-pro).

Per configurare un ambiente di sviluppo Overleaf ti servirà un server potente; si consiglia una configurazione di almeno 8 core e 16 GB di RAM, poiché dovrai eseguire più di 20 container contemporaneamente.

<Info>
  Poiché i server con 8 o più core CPU sono in genere costosi, si consiglia vivamente di usare il tuo computer locale per lo sviluppo.
</Info>

Inoltre, in quanto sviluppatore, riteniamo che tu abbia già familiarità con l'[installazione di Docker](https://docs.docker.com/engine/install/ubuntu/). Ti consigliamo vivamente di usare una versione Ubuntu LTS recente e stabile (ad es. Ubuntu 24.04 nel 2025–2026) e l'ultima versione di Docker per lo sviluppo, in modo da ridurre la possibilità di incontrare errori imprevisti.

In sintesi, ti servirà:

* [x] Un server/desktop potente per lo sviluppo
* [x] Una versione Ubuntu LTS recente e stabile (ad es. Ubuntu 24.04)
* [x] Un ambiente con Docker e Git

## Guida alla configurazione

Qui useremo overleaf-cep come esempio per mostrare come configurare un ambiente di sviluppo Overleaf.

<Steps>
  <Step title="Scaricare il codice sorgente">
    Prima di tutto cloniamo il repository:

    ```bash title="bash" theme={null}
    git clone https://github.com/ayaka-notes/overleaf-pro.git
    cd overleaf-pro
    ```
  </Step>

  <Step title="Sincronizzare `package-lock.json`">
    Poiché Overleaf viene sviluppato in un [repository interno](http://github.com/overleaf/internal), è molto probabile che il file `package-lock.json` non sia sincronizzato a causa di alcuni problemi di sviluppo. Dobbiamo eseguire il comando seguente per sincronizzarlo (se hai un ambiente nodejs locale):

    ```bash title="bash" theme={null}
    npm install --package-lock-only --ignore-scripts
    ```

    Se non hai nodejs installato, non preoccuparti: puoi usare direttamente `docker` per eseguire lo stesso comando. Eseguilo <strong>dalla radice del repository Overleaf:</strong>

    ```bash title="bash" theme={null}
    docker run --rm \
      -v "$(pwd)":/workspace \
      -w /workspace \
      node:22.18.0 \
      npm install --package-lock-only --ignore-scripts
    ```
  </Step>

  <Step title="Compilare l'immagine di sviluppo">
    Overleaf fornisce una directory dedicata `/develop` per conservare gli script di sviluppo. Compila semplicemente i servizi:

    ```bash title="bash" theme={null}
    cd ./develop
    bin/build
    ```

    <Info>
      Se Docker esaurisce la RAM durante la compilazione parallela dei servizi, crea in questa directory un file `.env` contenente `COMPOSE_PARALLEL_LIMIT=1`.
    </Info>
  </Step>

  <Step title="Avviare tutti i microservizi">
    Quindi avvia i servizi:

    ```bash title="bash" theme={null}
    bin/up
    ```

    Una volta che i servizi sono in esecuzione, apri [http://localhost/launchpad](http://localhost/launchpad) per creare il primo account amministratore.

    <Danger>
      Devi eseguire `bin/up` prima del comando `bin/dev`. In caso contrario potresti incontrare una serie di problemi di permessi.
    </Danger>
  </Step>
</Steps>

<Info>
  Per impostazione predefinita i privilegi di amministratore non sono disponibili. Devi aggiungere quanto segue a `develop/dev.env`. Dopodiché potrai accedere al pannello di amministrazione.

  ```text theme={null}
  ADMIN_PRIVILEGE_AVAILABLE=true
  ```
</Info>

### TeX Live

Per compilare un PDF è necessario creare un'immagine TeX Live che gestisca la compilazione all'interno di Docker:

```text theme={null}
docker build texlive -t texlive-full
```

Per compilare su un host macOS, potrebbe essere necessario sovrascrivere il percorso del socket Docker creando in questa directory un file `.env` contenente `DOCKER_SOCKET_PATH=/var/run/docker.sock.raw`

Puoi anche usare [ayaka-notes/texlive-full](https://github.com/ayaka-notes/texlive-full); in tal caso puoi usare il tag base, che corrisponde alla versione minima di texlive.

### Sviluppo

Per evitare di eseguire `bin/build && bin/up` dopo ogni modifica al codice, puoi eseguire Overleaf Community Edition in *modalità di sviluppo*, in cui i servizi si aggiornano automaticamente quando il codice cambia.

Per farlo, usa lo script incluso `bin/dev`:

```text theme={null}
bin/dev
```

Questo avvierà tutti i servizi usando `node --watch`, che monitorerà automaticamente il codice e riavvierà i servizi quando necessario.

Per migliorare le prestazioni, puoi avviare in modalità di sviluppo solo un sottoinsieme dei servizi, passando allo script `bin/dev` un elenco separato da spazi:

```text theme={null}
bin/dev [service1] [service2] ... [serviceN]
```

<Info>
  Avviare il servizio `web` in *modalità di sviluppo* aggiornerà il servizio `web` solo quando cambia il codice backend. Per aggiornare automaticamente anche il codice frontend, assicurati di avviare in *modalità di sviluppo* anche il servizio `webpack`.
</Info>

Se non viene indicato alcun servizio, tutti i servizi verranno avviati in modalità di sviluppo.

### Debug

In *modalità di sviluppo* la maggior parte dei servizi espone una porta di debug a cui puoi collegare un debugger, come l'inspector dei Dev Tools di Chrome o uno integrato in un IDE. La tabella seguente mostra la porta esposta sulla **macchina host** per ciascun servizio:

| Servizio | Porta |
| - | - |
| `web` | 9229 |
| `clsi` | 9230 |
| `chat` | 9231 |
| `contacts` | 9232 |
| `docstore` | 9233 |
| `document-updater` | 9234 |
| `filestore` | 9235 |
| `notifications` | 9236 |
| `real-time` | 9237 |
| `references` | 9238 |
| `history-v1` | 9239 |
| `project-history` | 9240 |
| `linked-url-proxy` | 9241 |

Per collegarti a un servizio tramite il *remote debugging* di Chrome, vai su chrome://inspect/ e assicurati che l'opzione *Discover network targets* sia selezionata. Quindi fai clic su *Configure...* e aggiungi una voce `localhost:[service port]` per ciascuno dei servizi a cui vuoi collegare un debugger.

Dopo aver aggiunto una voce, il servizio comparirà come *Remote Target* che potrai ispezionare ed eseguire in debug.

### Log

Nell'ambiente di sviluppo, Overleaf fornisce uno script `bin/logs`; tuttavia devi installare alcune dipendenze:

```bash theme={null}
sudo npm install -g bunyan
# Or sudo apt install node-bunyan 
```

In alternativa, puoi eseguire direttamente:

```text theme={null}
docker compose logs -f [service name]
```

### Altri strumenti

Una volta completato tutto, puoi consultare la [sezione successiva](/it/dev/environment/setup-develop-tools) per aggiungere alcuni strumenti di debug al tuo ambiente di sviluppo Overleaf.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.