> ## Documentation Index
> Fetch the complete documentation index at: https://help.teable.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Déploiement Docker

<Callout type="info">
  **Docker Compose est recommandé pour les petites équipes et les évaluations** (\< 50 utilisateurs).
  Vous ne savez pas si c’est la bonne solution ? Commencez par le [déploiement](/fr/deploy/choose). Vous avez besoin des fonctionnalités d’IA ou d’App Builder ? Pour un nouveau déploiement, déployez la [plateforme complète](/fr/deploy/architecture) ; si vous utilisez déjà cette configuration autonome, suivez le [guide de migration](https://github.com/teableio/teable-deployment/blob/main/migration/2026-07-basic-to-full-featured.md) — vos données restent en place.
</Callout>

## Déploiement avec Docker Compose

**Échelle recommandée** : 0 à 50 utilisateurs

| Avantages              | Inconvénients                                                |
| ---------------------- | ------------------------------------------------------------ |
| Déploiement simple     | Déploiement sur une seule machine, mise à l’échelle complexe |
| Contrôle total         |                                                              |
| Configuration flexible |                                                              |

**Configuration requise du serveur**

Assurez-vous que votre serveur respecte les exigences minimales suivantes :

* Système d’exploitation : distribution Linux recommandée, telle qu’Ubuntu 20.04 LTS
* Mémoire : 4 Go de RAM minimum
* CPU : au moins 2 cœurs
* Espace disque : 40 Go d’espace disponible minimum
* Réseau : connexion Internet stable avec l’accès aux ports nécessaires

#### Prérequis

Avant de commencer, assurez-vous de disposer de :

* Connaissances de base de Docker et des principes de conteneurisation
* Docker et Docker Compose installés sur votre machine. Consultez la documentation officielle de Docker pour les guides d’installation.

### **Installation de Docker**

```bash theme={null}
# Téléchargez la dernière version de Docker
curl -fsSL https://get.docker.com | bash -s docker

# Vérifiez l’installation
docker --version
docker-compose --version
```

### Installation de l’application

#### Créer le fichier docker-compose.yaml

Accédez à votre serveur, créez le dossier teable et entrez-y :

```bash theme={null}
mkdir teable

cd teable
```

Créez un fichier `docker-compose.yaml` et un fichier `.env`, puis collez le contenu suivant :

```bash theme={null}
vim docker-compose.yaml
```

#### **Déploiement minimal :**

```yaml docker-compose.yaml theme={null}
services:
  teable:
    image: ghcr.io/teableio/teable:latest
    restart: always
    ports:
      - '3000:3000'
    volumes:
      - teable-data:/app/.assets:rw
    env_file:
      - .env
    environment:
      - NEXT_ENV_IMAGES_ALL_REMOTE=true
    networks:
      - teable
    depends_on:
      teable-db:
        condition: service_healthy
      teable-cache:
        condition: service_healthy
    healthcheck:
      test: ['CMD', 'curl', '-f', 'http://localhost:3000/health']
      start_period: 5s
      interval: 5s
      timeout: 3s
      retries: 3

  teable-db:
    image: postgres:15.4
    restart: always
    ports:
      - '42345:5432'
    volumes:
      - teable-db:/var/lib/postgresql/data:rw
    environment:
      - POSTGRES_DB=${POSTGRES_DB}
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
    networks:
      - teable
    healthcheck:
      test: ['CMD-SHELL', "sh -c 'pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}'"]
      interval: 10s
      timeout: 3s
      retries: 3

  teable-cache:
    image: redis:7.2.4
    restart: always
    expose:
      - '6379'
    volumes:
      - teable-cache:/data:rw
    networks:
      - teable
    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD}
    healthcheck:
      test: ['CMD', 'redis-cli', '--raw', 'incr', 'ping']
      interval: 10s
      timeout: 3s
      retries: 3

networks:
  teable:
    name: teable-network

volumes:
  teable-db: {}
  teable-data: {}
  teable-cache: {}
```

```bash .env theme={null}
# Remplacez le mot de passe par défaut ci-dessous par un mot de passe robuste (ASCII) d’au moins 8 caractères.
POSTGRES_PASSWORD=replace_this_password
REDIS_PASSWORD=replace_this_password
SECRET_KEY=replace_this_secret_key

# Remplacez l’adresse suivante par une adresse accessible publiquement
PUBLIC_ORIGIN=http://127.0.0.1:3000

# ---------------------

# Postgres
POSTGRES_HOST=teable-db
POSTGRES_PORT=5432
POSTGRES_DB=teable
POSTGRES_USER=teable

# Redis
REDIS_HOST=teable-cache
REDIS_PORT=6379
REDIS_DB=0

# Application
PRISMA_DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
BACKEND_CACHE_PROVIDER=redis
BACKEND_CACHE_REDIS_URI=redis://default:${REDIS_PASSWORD}@${REDIS_HOST}:${REDIS_PORT}/${REDIS_DB}
```

#### **Ajout d’un service de stockage (facultatif)**

Pour les déploiements de production, utilisez un **stockage d’objets compatible S3** (tel que S3, MinIO, OSS/OBS/COS avec des points de terminaison compatibles S3, ou un autre service compatible S3) afin d’améliorer la durabilité et la mise à l’échelle.

<Tabs>
  <Tab title="Ajouter MinIO à docker-compose">
    MinIO fournit une interface supplémentaire de gestion du stockage (port 9001) ainsi qu’un service de fichiers plus puissant et plus stable.

    ```yaml docker-compose.yaml theme={null}
    services:
      # ...contenu précédent
      teable-storage:
        image: minio/minio:RELEASE.2024-02-17T01-15-57Z
        ports:
          - "9000:9000"
          - "9001:9001"
        environment:
          - MINIO_ACCESS_KEY=${MINIO_ACCESS_KEY}
          - MINIO_SECRET_KEY=${MINIO_SECRET_KEY}
        volumes:
          - teable-storage:/data:rw
        networks:
          - teable
        command: server /data --console-address ":9001"
      createbuckets:
        image: minio/mc
        networks:
          - teable
        entrypoint: >
          /bin/sh -c "
          /usr/bin/mc alias set teable-storage http://teable-storage:9000 ${MINIO_ACCESS_KEY} ${MINIO_SECRET_KEY};
          /usr/bin/mc mb teable-storage/public;
          /usr/bin/mc anonymous set public teable-storage/public;
          /usr/bin/mc mb teable-storage/private;
          exit 0;
          "
        depends_on:
          teable-storage:
            condition: service_started

    networks:
      teable:
        name: teable-network

    volumes:
      teable-db: {}
      teable-cache: {}
      # Ajoutez un nouveau volume
      teable-storage: {}

    ```

    ```bash .env theme={null}
    # Remplacez les mots de passe par défaut ci-dessous par des mots de passe robustes (ASCII) d’au moins 8 caractères.
    POSTGRES_PASSWORD=replace_this_password
    REDIS_PASSWORD=replace_this_password
    SECRET_KEY=replace_this_secret_key

    # Si vous activez HTTPS, définissez PROTOCOL sur https.
    PROTOCOL=http
    # Définissez PUBLIC_HOST sur l’adresse IP ou le nom de domaine de votre déploiement. localhost et 127.0.0.1 ne sont pas autorisés.
    PUBLIC_HOST=192.168.x.x
    # Modifiez le dernier port pour qu’il corresponde à votre port d’accès, ou supprimez :port si vous utilisez les ports standard (80/443).
    PUBLIC_ORIGIN=${PROTOCOL}://${PUBLIC_HOST}:3000

    # ---------------------

    # Postgres
    POSTGRES_HOST=teable-db
    POSTGRES_PORT=5432
    POSTGRES_DB=teable
    POSTGRES_USER=teable

    # Redis
    REDIS_HOST=teable-cache
    REDIS_PORT=6379
    REDIS_DB=0

    # MinIO
    MINIO_ACCESS_KEY=teable_minio_access
    MINIO_SECRET_KEY=${SECRET_KEY}

    # Application
    PRISMA_DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
    BACKEND_CACHE_PROVIDER=redis
    BACKEND_CACHE_REDIS_URI=redis://default:${REDIS_PASSWORD}@${REDIS_HOST}:${REDIS_PORT}/${REDIS_DB}
    BACKEND_STORAGE_PROVIDER=minio
    BACKEND_STORAGE_PUBLIC_BUCKET=public
    BACKEND_STORAGE_PRIVATE_BUCKET=private
    BACKEND_STORAGE_MINIO_USE_SSL=false # Si vous activez HTTPS, remplacez cette valeur par true
    BACKEND_STORAGE_MINIO_ENDPOINT=${PUBLIC_HOST}
    BACKEND_STORAGE_MINIO_PORT=9000
    BACKEND_STORAGE_MINIO_ACCESS_KEY=${MINIO_ACCESS_KEY}
    BACKEND_STORAGE_MINIO_SECRET_KEY=${MINIO_SECRET_KEY}
    STORAGE_PREFIX=${PROTOCOL}://${PUBLIC_HOST}:${BACKEND_STORAGE_MINIO_PORT}
    ```
  </Tab>

  <Tab title="Se connecter à MinIO externe">
    Avant de commencer, vous devez créer deux buckets dans MinIO. Un bucket public stocke les images de profil et les en-têtes de formulaire, et un bucket privé stocke le contenu des pièces jointes.

    ```sh .env theme={null}
    # ...contenu précédent
    # Utilisez le fournisseur MinIO
    BACKEND_STORAGE_PROVIDER=minio
    # Nom du bucket public
    BACKEND_STORAGE_PUBLIC_BUCKET=public
    # Nom du bucket privé
    BACKEND_STORAGE_PRIVATE_BUCKET=private
    # Adresse IP ou nom de domaine du point de terminaison du service MinIO
    BACKEND_STORAGE_MINIO_ENDPOINT=minio.example.com
    # Port MinIO
    BACKEND_STORAGE_MINIO_PORT=443
    # Indique si HTTPS est activé
    BACKEND_STORAGE_MINIO_USE_SSL=true
    # Clé d’accès MinIO
    BACKEND_STORAGE_MINIO_ACCESS_KEY=_minio_access_key_
    # Clé secrète MinIO
    BACKEND_STORAGE_MINIO_SECRET_KEY=_minio_secret_key_
    # Adresse d’accès complète
    STORAGE_PREFIX=https://minio.example.com

    # ---Configuration du réseau interne (facultatif)---
    # Adresse IP ou nom de domaine interne du point de terminaison du service MinIO (non pris en charge avec HTTPS)
    BACKEND_STORAGE_MINIO_INTERNAL_ENDPOINT=teable-storage.internal
    # Port MinIO interne
    BACKEND_STORAGE_MINIO_INTERNAL_PORT=9000
    # ---Configuration de la région (facultatif)---
    # Nom de la région
    BACKEND_STORAGE_MINIO_REGION=us-east-1

    ```
  </Tab>

  <Tab title="Se connecter à AWS S3">
    <Note>
      Remarque : vous devez configurer **deux buckets** (public/privé). Le **bucket public** doit être en **lecture publique** et doit autoriser le **CORS pour toute origine**, faute de quoi l’accès depuis le navigateur peut échouer.
    </Note>

    Avant de commencer, vous devez créer deux buckets dans AWS S3. Un bucket public sert à stocker les avatars et les en-têtes de formulaire, et un bucket privé sert à stocker le contenu des pièces jointes.

    ```sh .env theme={null}
    # ...contenu précédent
    # Utilisez le fournisseur S3 standard
    BACKEND_STORAGE_PROVIDER=s3
    # Nom de la région
    BACKEND_STORAGE_S3_REGION=us-west-2
    # Point de terminaison, avec protocole obligatoire (généralement https)
    BACKEND_STORAGE_S3_ENDPOINT=https://s3.us-west-2.amazonaws.com
    # Clé d’accès
    BACKEND_STORAGE_S3_ACCESS_KEY=access_key
    # Clé secrète
    BACKEND_STORAGE_S3_SECRET_KEY=secret_key
    # Bucket public
    BACKEND_STORAGE_PUBLIC_BUCKET=your-public-bucket
    # Bucket privé
    BACKEND_STORAGE_PRIVATE_BUCKET=your-private-bucket
    # Adresse d’accès complète, c’est-à-dire l’adresse d’accès de votre bucket public
    STORAGE_PREFIX=https://your-public-bucket.s3.us-west-2.amazonaws.com

    ```

    Ce processus s’applique à la plupart des fournisseurs cloud, pas seulement à AWS S3.
  </Tab>
</Tabs>

#### Démarrer l’application

Exécutez les commandes suivantes dans le répertoire actuel pour démarrer l’application. Une fois démarrée, vous pouvez y accéder à l’adresse 127.0.0.1:3000.

<Note>
  Un environnement HTTPS est requis pour les opérations de copie de données à grande échelle ; sinon, l’accès asynchrone au presse-papiers ne sera pas possible.
</Note>

```bash theme={null}
docker-compose pull

docker-compose up -d
```

#### Utiliser des bases de données gérées (facultatif)

Si vous préférez utiliser des bases de données gérées, vous pouvez simplifier davantage le processus de déploiement :

1. Supprimez services.teable-db
2. Supprimez volumes.teable-db
3. Mettez à jour .env avec la configuration de votre base de données gérée

Renseignez les paramètres de base de données avec ceux de connexion à votre base de données gérée :

```sh .env theme={null}
POSTGRES_HOST=your-database.com
POSTGRES_PORT=5432
POSTGRES_DB=teable
POSTGRES_USER=teable
```

<Note>
  Notez que `127.0.0.1` correspond au réseau interne du conteneur. Si vous souhaitez vous connecter à une base de données déployée localement, utilisez `host.docker.internal` au lieu de `127.0.0.1` comme adresse d’hôte ; sinon, la connexion échouera.
</Note>

**De même pour Redis géré externe :**

* Supprimez service.teable-cache
* Supprimez service.teable.depends\_on.teable-cache
* Supprimez volumes.teable-cache
* Mettez à jour .env avec votre configuration Redis gérée

### Étapes suivantes

[Configurer le service d’e-mail](/fr/deploy/email)

## Assistance et retours

Si vous rencontrez des problèmes lors du déploiement, contactez notre équipe d’assistance à l’adresse [support@teable.ai](mailto:support@teable.ai) ou [signalez un problème](https://github.com/teableio/teable/issues).

## Licence

Teable comprend des fonctionnalités Community open source sous licence AGPL-3.0. Pour débloquer les fonctionnalités payantes dans les déploiements Auto-hébergé, veuillez vous abonner sur notre [page de tarification](https://app.teable.ai/public/pricing?host=self-hosted\&billing=year).

<Note>
  L’image `ghcr.io/teableio/teable:latest` inclut l’ensemble complet de fonctionnalités. Les fonctionnalités payantes nécessitent une licence d’abonnement valide pour être activées.

  Si vous avez uniquement besoin de l’ensemble de fonctionnalités Community open source, vous pouvez choisir l’image `ghcr.io/teableio/teable-community:latest`.
</Note>

## Problèmes fréquents

<Accordion title="Comment me connecter après le premier déploiement ?">
  Après le démarrage de l’instance, ouvrez l’URL de votre instance et créez-y un compte. Teable n’est pas fourni avec un compte administrateur prédéfini, et votre instance Auto-hébergé n’utilise pas votre compte cloud teable.ai.

  Le premier utilisateur qui s’inscrit sur l’instance devient l’administrateur de l’instance.
</Accordion>

<Accordion title="Pourquoi ne puis-je pas importer de CSV/xlsx ni téléverser d’images après l’installation ?">
  Les problèmes d’importation de fichiers sont généralement dus à une configuration incorrecte de la variable d’environnement PUBLIC\_ORIGIN. Vous devez définir PUBLIC\_ORIGIN sur l’adresse actuellement accessible :

  ```bash theme={null}
  # Pour le développement local
  PUBLIC_ORIGIN=http://127.0.0.1:3000

  # Pour l’accès au réseau local
  PUBLIC_ORIGIN=http://192.168.1.100:3000

  # Pour l’accès par nom de domaine
  PUBLIC_ORIGIN=https://teable.example.com
  ```

  <Callout type="warning">
    Important : n’ajoutez pas de barre oblique finale ("/") à la fin de l’URL.
  </Callout>

  Après avoir modifié cette configuration, vous devrez redémarrer votre instance Teable pour que les modifications prennent effet.
</Accordion>

<Accordion title="Comment activer HTTPS ?">
  L’activation de HTTPS requiert les étapes suivantes :

  * Obtenez un certificat SSL valide
  * Définissez `PROTOCOL=https` (ou définissez `PUBLIC_ORIGIN=https://teable.example.com` selon votre configuration)
  * Si vous utilisez MinIO, définissez `BACKEND_STORAGE_MINIO_USE_SSL=true`

  <Tip>
    Il est recommandé d’utiliser un proxy inverse (comme Nginx ou Traefik) pour gérer la terminaison SSL.
  </Tip>

  <Tip>
    Si vous ne savez pas comment configurer Nginx (HTTPS/certificats, WebSocket, réseau Docker, Nginx Proxy Manager, etc.), consultez : [Nginx (proxy inverse)](/fr/deploy/nginx).
  </Tip>
</Accordion>

<Accordion title="Comment sauvegarder mes données ?">
  Pour les déploiements Docker Compose, plusieurs options de sauvegarde sont disponibles :

  **Option 1 : sauvegarde complète de machine virtuelle** (recommandée pour sa simplicité)

  * Sauvegardez régulièrement l’intégralité de la machine virtuelle qui héberge Teable
  * Offre une capacité complète de restauration du système

  **Option 2 : sauvegarde des volumes Docker**

  * Sauvegardez tous les volumes Docker définis dans votre `docker-compose.yaml`
  * Lister les volumes : `docker volume ls`
  * Sauvegarder un volume :
    ```bash theme={null}
    docker run --rm -v <volume_name>:/data -v $(pwd):/backup alpine tar czf /backup/<volume_name>.tar.gz /data
    ```

  **Option 3 : sauvegarde au niveau des composants** (recommandée pour un contrôle précis)

  * **Base de données PostgreSQL** : contient toutes les données des tables
    ```bash theme={null}
    docker exec teable-db pg_dump -U teable teable > backup.sql
    ```
  * **Base de données Redis** : contient les données de file d’attente d’automatisation
    ```bash theme={null}
    docker exec teable-cache redis-cli --rdb /data/dump.rdb
    ```
  * **Répertoire de données** : sauvegardez le volume `teable-data` (contient tous les fichiers joints)
    ```bash theme={null}
    docker run --rm -v teable-data:/data -v $(pwd):/backup alpine tar czf /backup/teable-data.tar.gz /data
    ```

  Pour les environnements de production, nous recommandons de mettre en place des sauvegardes quotidiennes automatisées avec des politiques de rétention.
</Accordion>