> ## 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.

# Konfigurera utvecklingsmiljön (lokalt)

> Konfigurera din utvecklingsmiljö på din lokala server eller dator.

## Förutsättningar

Overleaf är ett typiskt open source-projekt med mikrotjänstarkitektur, där alla tjänster körs i Docker. 

* Källkoden för den officiella Community Edition finns på [GitHub Overleaf Official](https://github.com/overleaf/overleaf/tree). 
* Källkoden för Overleaf-CEP finns på [GitHub Yu-i-i/Overleaf](https://github.com/yu-i-i/overleaf-cep).
* Overleaf Pro Edition finns på [GitHub Ayaka-notes/overleaf-pro](https://github.com/ayaka-notes/overleaf-pro).

För att sätta upp en utvecklingsmiljö för Overleaf behöver du en kraftfull server; en konfiguration med minst 8 kärnor och 16 GB RAM rekommenderas, eftersom du behöver köra fler än 20 containrar samtidigt.

<Info>
  Eftersom servrar med 8 eller fler CPU-kärnor vanligtvis är dyra rekommenderar vi starkt att du använder din lokala dator för utveckling.
</Info>

Som utvecklare förutsätter vi samtidigt att du redan är bekant med [installation av Docker](https://docs.docker.com/engine/install/ubuntu/). Vi rekommenderar starkt att du använder en aktuell och stabil Ubuntu LTS (t.ex. Ubuntu 24.04 under 2025–2026) och den senaste versionen av Docker för utveckling, eftersom det minskar risken för oväntade fel.

Sammanfattningsvis behöver du:

* [x] En kraftfull server/dator att utveckla på
* [x] En aktuell och stabil Ubuntu LTS (t.ex. Ubuntu 24.04)
* [x] En miljö med Docker och Git

## Konfigurationsguide

Här använder vi overleaf-cep som exempel för att visa hur du konfigurerar en utvecklingsmiljö för Overleaf.

<Steps>
  <Step title="Hämta källkoden">
    Först klonar vi repot:

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

  <Step title="Synkronisera `package-lock.json`">
    Eftersom Overleaf utvecklas i ett [internt repository](http://github.com/overleaf/internal) är det mycket troligt att filen `package-lock.json` blir osynkroniserad på grund av vissa utvecklingsproblem. Vi behöver köra följande kommando för att synkronisera den (om du har en lokal nodejs-miljö).

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

    Om du inte har nodejs installerat behöver du inte oroa dig – du kan använda `docker` direkt för att köra samma kommando. Kör <strong>från roten av Overleaf-repot:</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="Bygg utvecklingsavbildningen">
    Overleaf tillhandahåller en särskild katalog, `/develop`, för utvecklingsskript. Bygg bara tjänsterna:

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

    <Info>
      Om Docker får slut på RAM när tjänsterna byggs parallellt skapar du en `.env`-fil i den här katalogen som innehåller `COMPOSE_PARALLEL_LIMIT=1`.
    </Info>
  </Step>

  <Step title="Starta alla mikrotjänster">
    Starta sedan tjänsterna:

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

    När tjänsterna körs öppnar du [http://localhost/launchpad](http://localhost/launchpad) för att skapa det första administratörskontot.

    <Danger>
      Du måste köra `bin/up` innan du kör kommandot `bin/dev`. Annars kan du stöta på en rad behörighetsproblem.
    </Danger>
  </Step>
</Steps>

<Info>
  Som standard är administratörsbehörighet inte tillgänglig. Du behöver lägga till följande i `develop/dev.env`. Därefter får du åtkomst till adminpanelen.

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

### TeX Live

För att kompilera en PDF behöver du bygga en TeX Live-avbildning som hanterar kompileringen i Docker:

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

För att kompilera på en macOS-värd kan du behöva åsidosätta sökvägen till Docker-socketen genom att skapa en `.env`-fil i den här katalogen som innehåller `DOCKER_SOCKET_PATH=/var/run/docker.sock.raw`

Du är också välkommen att använda [ayaka-notes/texlive-full](https://github.com/ayaka-notes/texlive-full), men du kan använda taggen base, som är den minsta versionen av texlive.

### Utveckling

För att slippa köra `bin/build && bin/up` efter varje kodändring kan du köra Overleaf Community Edition i *utvecklingsläge*, där tjänsterna uppdateras automatiskt vid kodändringar.

Använd det medföljande skriptet `bin/dev` för detta:

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

Detta startar alla tjänster med `node --watch`, som automatiskt övervakar koden och startar om tjänsterna vid behov.

För bättre prestanda kan du starta endast en delmängd av tjänsterna i utvecklingsläge genom att ange en blankstegsseparerad lista till skriptet `bin/dev`:

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

<Info>
  Om tjänsten `web` startas i *utvecklingsläge* uppdateras tjänsten `web` endast när backendkoden ändras. För att även frontendkoden ska uppdateras automatiskt ser du till att också starta tjänsten `webpack` i *utvecklingsläge*.
</Info>

Om inga tjänster anges startar alla tjänster i utvecklingsläge.

### Felsökning

När de körs i *utvecklingsläge* exponerar de flesta tjänster en felsökningsport som du kan ansluta en debugger till, till exempel inspektören i Chromes Dev Tools eller en debugger som är integrerad i en IDE. Följande tabell visar vilken port som exponeras på **värddatorn** för varje tjänst:

| Tjänst | Port |
| - | - |
| `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 |

För att ansluta till en tjänst med Chromes *fjärrfelsökning* går du till chrome://inspect/ och ser till att *Discover network targets* är markerat. Klicka sedan på *Configure...* och lägg till en post `localhost:[service port]` för var och en av de tjänster du vill ansluta en debugger till.

När du har lagt till en post visas tjänsten som ett *Remote Target* som du kan inspektera och felsöka.

### Loggning

I utvecklingsmiljön tillhandahåller Overleaf skriptet `bin/logs`, men du behöver installera vissa beroenden:

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

Alternativt kan du köra direkt med:

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

### Andra verktyg

När du är klar med allt kan du läsa [nästa avsnitt](/sv/dev/environment/setup-develop-tools) för att lägga till felsökningsverktyg i din Overleaf-utveckling.


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