twenty/packages/twenty-docs/l/fr/developers/local-setup.mdx

---
title: Configuration Locale
description: "Le guide pour les contributeurs (ou les développeurs curieux) qui souhaitent exécuter Twenty localement."
image: /images/user-guide/fields/field.png
---

<Frame>
  <img src="/images/user-guide/fields/field.png" alt="Header" />
</Frame>

## Prérequis

<Tabs>
<Tab title="Linux and MacOS">

Avant de pouvoir installer et utiliser Twenty, assurez-vous d'installer ce qui suit sur votre ordinateur :

- [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
- [Node v24.5.0](https://nodejs.org/en/download)
- [yarn v4](https://yarnpkg.com/getting-started/install)
- [nvm](https://github.com/nvm-sh/nvm/blob/master/README.md)

<Warning>
`npm` ne fonctionnera pas, vous devez utiliser `yarn` à la place. Yarn est maintenant intégré avec Node.js, vous n'avez donc pas besoin de l'installer séparément.
Vous devez uniquement exécuter `corepack enable` pour activer Yarn si vous ne l'avez pas encore fait.
</Warning>

</Tab>

<Tab title="Windows (WSL)">

1. Installer WSL
   Ouvrez PowerShell en tant qu'administrateur et exécutez :

```powershell
wsl --install
```

Vous devriez maintenant voir une invite pour redémarrer votre ordinateur. Si ce n'est pas le cas, redémarrez-le manuellement.

Au redémarrage, une fenêtre PowerShell s'ouvrira et installera Ubuntu. Cela peut prendre un peu de temps.
Une invite pour créer un nom d'utilisateur et un mot de passe pour votre installation Ubuntu s'affichera.

2. Installez et configurez git

```bash
sudo apt-get install git

git config --global user.name "Your Name"

git config --global user.email "youremail@domain.com"
```

3. Installez nvm, node.js et yarn <Warning>

<Warning>
Utilisez `nvm` pour installer la version correcte de `node`. Le fichier `.nvmrc` garantit que tous les contributeurs utilisent la même version.
</Warning>

```bash
sudo apt-get install curl

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/master/install.sh | bash
```

Fermez et rouvrez votre terminal pour utiliser nvm. Ensuite, exécutez les commandes suivantes.

```bash

nvm install # installs recommended node version

nvm use # use recommended node version

corepack enable
```

</Tab>
</Tabs>

---

## Étape 1 : Cloner Git

Dans votre terminal, exécutez la commande suivante.

<Tabs>
<Tab title="SSH (Recommended)">
Si vous n'avez pas encore configuré les clés SSH, vous pouvez apprendre à le faire [ici](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/about-ssh).
```bash
git clone git@github.com:twentyhq/twenty.git
```
</Tab>
<Tab title="HTTPS">

```bash
git clone https://github.com/twentyhq/twenty.git
```

</Tab>
</Tabs>

## Étape 2 : Positionnez-vous à la racine

```bash
cd twenty
```

Vous devez exécuter toutes les commandes des étapes suivantes depuis la racine du projet.

## Étape 3 : Configurez une base de données PostgreSQL

<Tabs>
  <Tab title="Linux">
    **Option 1 (préférée) :** Pour créer votre base de données localement :
    Utilisez le lien suivant pour installer PostgreSQL sur votre machine Linux : [Installation de PostgreSQL](https://www.postgresql.org/download/linux/)
    ```bash
      psql postgres -c "CREATE DATABASE \"default\";" -c "CREATE DATABASE test;"
    ```
    Note : Vous pourriez avoir besoin d'ajouter `sudo -u postgres` à la commande avant `psql` pour éviter des erreurs de permission.

````
**Option 2:** If you have docker installed:
```bash
  make postgres-on-docker
```
````

  </Tab>
  <Tab title="Mac OS">
    **Option 1 (préférée) :** Pour créer votre base de données localement avec `brew` :

````
```bash
  brew install postgresql@16
  export PATH="/opt/homebrew/opt/postgresql@16/bin:$PATH"
  brew services start postgresql@16
  psql postgres -c "CREATE DATABASE \"default\";" -c "CREATE DATABASE test;"
```

You can verify if the PostgreSQL server is running by executing:
```bash
  brew services list
```

The installer might not create the `postgres` user by default when installing
via Homebrew on MacOS. Instead, it creates a PostgreSQL role that matches your macOS
username (e.g., "john").
To check and create the `postgres` user if necessary, follow these steps:
```bash
  # Connect to PostgreSQL
  psql postgres
  or
  psql -U $(whoami) -d postgres
```

Once at the psql prompt (postgres=#), run:
 ```bash
  # List existing PostgreSQL roles
  \du
```
You'll see output similar to:
 ```bash
  Role name | Attributes  | Member of
  -----------+-------------+-----------
  john      | Superuser   | {}
```

If you do not see a `postgres` role listed, proceed to the next step.
Create the `postgres` role manually:
 ```bash
  CREATE ROLE postgres WITH SUPERUSER LOGIN;
```
This creates a superuser role named `postgres` with login access.

**Option 2:** If you have docker installed:
```bash
  make postgres-on-docker
```
````

  </Tab>
  <Tab title="Windows (WSL)">
    Toutes les étapes suivantes doivent être exécutées dans le terminal WSL (dans votre machine virtuelle)

````
**Option 1:** To provision your Postgresql locally:
Use the following link to install Postgresql on your Linux virtual machine: [Postgresql Installation](https://www.postgresql.org/download/linux/)
```bash
  psql postgres -c "CREATE DATABASE \"default\";" -c "CREATE DATABASE test;"
```
Note: You might need to add `sudo -u postgres` to the command before `psql` to avoid permission errors.

**Option 2:** If you have docker installed:
Running Docker on WSL adds an extra layer of complexity.
Only use this option if you are comfortable with the extra steps involved, including turning on [Docker Desktop WSL2](https://docs.docker.com/desktop/wsl).
```bash
  make postgres-on-docker
```
````

  </Tab>
</Tabs>

Vous pouvez maintenant accéder à la base de données à [localhost:5432](localhost:5432), avec l'utilisateur `postgres` et le mot de passe `postgres`.

## Étape 4 : Configuration d'une base de données Redis (cache)

Twenty nécessite un cache Redis pour offrir la meilleure performance

<Tabs>
  <Tab title="Linux">
    **Option 1 :** Pour configurer votre Redis localement :
    Utilisez le lien suivant pour installer Redis sur votre machine Linux : [Installation de Redis](https://redis.io/docs/latest/operate/oss_and_stack/install/install-redis/install-redis-on-linux/)

````
**Option 2:** If you have docker installed:
```bash
  make redis-on-docker
```
````

  </Tab>
  <Tab title="Mac OS">
    **Option 1 (préférée) :** Pour configurer votre Redis localement avec `brew` :
    ```bash
    brew install redis
    ```
    Démarrez votre serveur redis :
    ```brew services start redis```

````
**Option 2:** If you have docker installed:
```bash
  make redis-on-docker
```
````

  </Tab>
  <Tab title="Windows (WSL)">
    **Option 1 :** Pour configurer votre Redis localement :
    Utilisez le lien suivant pour installer Redis sur votre machine virtuelle Linux : [Installation de Redis](https://redis.io/docs/latest/operate/oss_and_stack/install/install-redis/install-redis-on-linux/)

````
**Option 2:** If you have docker installed:
```bash
  make redis-on-docker
```
````

  </Tab>
</Tabs>

Si vous avez besoin d'une interface graphique cliente, nous recommandons [redis insight](https://redis.io/insight/) (version gratuite disponible)

## Étape 5 : Configurer les variables d'environnement

Utilisez des variables d'environnement ou des fichiers `.env` pour configurer votre projet. Plus d'informations [ici](https://docs.twenty.com/l/fr/developers/self-hosting/setup)

Copiez les fichiers `.env.example` dans `/front` et `/server` :

```bash
cp ./packages/twenty-front/.env.example ./packages/twenty-front/.env
cp ./packages/twenty-server/.env.example ./packages/twenty-server/.env
```

## Étape 6 : Installation des dépendances

Pour construire le serveur Twenty et injecter des données dans votre base de données, exécutez la commande suivante :

```bash
yarn
```

Notez que `npm` ou `pnpm` ne fonctionneront pas

## Étape 7 : Exécution du projet

<Tabs>
  <Tab title="Linux">
    Selon votre distribution Linux, le serveur Redis peut être démarré automatiquement.
    Sinon, vérifiez le [guide d'installation de Redis](https://redis.io/docs/latest/operate/oss_and_stack/install/install-redis/) pour votre distribution.
  </Tab>
  <Tab title="Mac OS">
  Redis devrait déjà être en cours d'exécution. Si ce n'est pas le cas, exécutez :
    ```bash
    brew services start redis
    ```  
</Tab>
  <Tab title="Windows (WSL)">
    Selon votre distribution Linux, le serveur Redis peut être démarré automatiquement.
    Sinon, vérifiez le [guide d'installation de Redis](https://redis.io/docs/latest/operate/oss_and_stack/install/install-redis/) pour votre distribution.
  </Tab>
</Tabs>

Configurez votre base de données avec la commande suivante :

```bash
npx nx database:reset twenty-server
```

Démarrez le serveur, le worker et les services frontend :

```bash
npx nx start twenty-server
npx nx worker twenty-server
npx nx start twenty-front
```

Alternativement, vous pouvez démarrer tous les services en même temps :

```bash
npx nx start
```

## Étape 8 : Utiliser Twenty

**Frontend**

Le frontend de Twenty sera en cours d'exécution à [http://localhost:3001](http://localhost:3001).
Vous pouvez vous connecter en utilisant le compte démo par défaut : `tim@apple.dev` (mot de passe : `tim@apple.dev`)

**Backend**

- Le serveur de Twenty sera en fonctionnement à [http://localhost:3000](http://localhost:3000)
- L'API GraphQL est accessible à [http://localhost:3000/graphql](http://localhost:3000/graphql)
- L'API REST est joignable à [http://localhost:3000/rest](http://localhost:3000/rest)

## Résolution des problèmes

Si vous rencontrez un problème, consultez [Dépannage](https://docs.twenty.com/l/fr/developers/self-hosting/troubleshooting) pour des solutions.