# Guide de déploiement

> Choisissez la forme de déploiement d’une application Server SDK selon son échelle, de la machine unique aux nœuds de collaboration multiples.

- Human documentation: [https://docs.univer.ai/fr-FR/server/deployment](https://docs.univer.ai/fr-FR/server/deployment)

- Agent Markdown: [https://docs.univer.ai/fr-FR/server/deployment.md](https://docs.univer.ai/fr-FR/server/deployment.md)

- Requested language: `fr-FR`

- Content language: `fr-FR`

- Documentation version: `1.2.0`

- Source: [deployment.fr-FR.mdx](https://github.com/dream-num/documentation/blob/dev/content/server/deployment.fr-FR.mdx)

---

Cette page décrit trois formes de déploiement d’une application Server SDK selon l’échelle. Lisez d’abord [Collaboration SDK](https://docs.univer.ai/fr-FR/server/collaboration/overview.md), [import et export](https://docs.univer.ai/fr-FR/server/import-export.md) et les [exemples](https://docs.univer.ai/fr-FR/server/collaboration/examples.md) pour voir comment les modules s’assemblent ; le déploiement place ce même assemblage sur un ou plusieurs nœuds.

| Forme                                                       | Collaboration   | Import et export | Échelle recommandée                                                          |
| ----------------------------------------------------------- | --------------- | ---------------- | ---------------------------------------------------------------------------- |
| [Machine unique](#machine-unique)                           | Un nœud         | Même nœud        | Applications locales, développement et tests, quelques utilisateurs internes |
| [Séparer l’import et l’export](#séparer-limport-et-lexport) | Un nœud         | Nœud distinct    | Service en ligne multi-utilisateurs dans la capacité d’un nœud               |
| [Plusieurs nœuds](#plusieurs-nœuds-de-collaboration)        | Plusieurs nœuds | Nœud distinct    | Au-delà de la capacité d’un nœud, ou basculement entre nœuds                 |

## Machine unique

Toutes les fonctions sont déployées dans un seul processus Node.js et le navigateur s’y connecte directement.

```mermaid
%%{init: {"themeVariables": {"fontSize": "14px"}, "flowchart": {"nodeSpacing": 24, "rankSpacing": 40, "padding": 12}}}%%
flowchart LR
    Browser(["Navigateur"]) --> App["Collaboration + Exchange"]
    App --> DB[("Base de données")]
    classDef default rx:8,ry:8,stroke-width:1px
    classDef actor fill:transparent,stroke:none
    class Browser actor
```

* Le Database Adapter implémente le contrat `IDatabaseAdapter` ; voir [Adaptateurs de base de données](https://docs.univer.ai/fr-FR/server/collaboration/database-adapters.md).
* Le stockage des tâches et des fichiers, les délais d’expiration et les liens de téléchargement de l’import et de l’export sont décrits dans [Intégration de l’échange de fichiers](https://docs.univer.ai/fr-FR/server/import-export.md).
* Une conversion sollicite fortement le processeur et un fichier volumineux ralentit la collaboration.

Séparez l’import et l’export lorsque les conversions pèsent sur la réactivité de la collaboration ou que le service doit servir de nombreux utilisateurs en continu.

## Séparer l’import et l’export

L’import et l’export passent sur un nœud distinct ; la collaboration reste sur un nœud ; la passerelle route séparément les deux types de chemins ; les deux utilisent la même base de données.

```mermaid
%%{init: {"themeVariables": {"fontSize": "14px"}, "flowchart": {"nodeSpacing": 24, "rankSpacing": 40, "padding": 12}}}%%
flowchart LR
    Browser(["Navigateur"]) --> Gateway["Passerelle"]
    Gateway -->|"Requêtes de collaboration"| Node["Nœud de collaboration"]
    Gateway -->|"Requêtes d’import et d’export"| Exchange["Nœud d’import et d’export"]
    Node --> DB[("Base de données")]
    Exchange --> DB
    classDef default rx:8,ry:8,stroke-width:1px
    classDef actor fill:transparent,stroke:none
    class Browser actor
```

Le nœud d’import et d’export assemble le Database Adapter, un `UniverCollabService` et le module de conversion, et accède directement à la base de données ; les points d’injection sont les mêmes que sur une machine unique.

Les documents servis par un seul nœud de collaboration sont limités par la mémoire du processus. Passez à plusieurs nœuds au-delà de cette capacité ou pour le basculement.

## Plusieurs nœuds de collaboration

Plusieurs nœuds de collaboration exécutent le même code sur la même base de données. Un adaptateur pub/sub relaie les Rooms, la Presence et les diffusions entre les nœuds, un ticket store partage les Session Tickets et `@univerjs-pro/collaboration-cluster-redis` fournit l’implémentation Redis. Exemple de référence : [Multi-node](https://docs.univer.ai/fr-FR/server/collaboration/examples.md#multi-node).

```mermaid
%%{init: {"themeVariables": {"fontSize": "14px"}, "flowchart": {"nodeSpacing": 24, "rankSpacing": 40, "padding": 12}}}%%
flowchart LR
    Browser(["Navigateur"]) --> Gateway["Passerelle"]
    subgraph Nodes["Nœuds de collaboration"]
        direction TB
        A["Nœud A"]
        B["Nœud B"]
    end
    Gateway -->|"Requêtes de collaboration"| A
    Gateway --> B
    subgraph Exchange["Nœuds d’import et d’export"]
        direction TB
        X1["Nœud A"]
        X2["Nœud B"]
    end
    Gateway -->|"Requêtes d’import et d’export"| X1
    Gateway --> X2
    A --- PubSub[("pub/sub + ticket store")]
    B --- PubSub
    A --> DB[("Base de données")]
    B --> DB
    X1 --> DB
    X2 --> DB
    classDef default rx:8,ry:8,stroke-width:1px
    classDef actor fill:transparent,stroke:none
    class Browser actor
```

Chaque nœud de collaboration transmet l’adaptateur pub/sub et le ticket store Redis à l’Endpoint ; le reste de l’assemblage reste identique :

```ts
import { createClient } from "redis";
import { RedisPubSubAdapter, RedisSessionTicketStore } from "@univerjs-pro/collaboration-cluster-redis";
import { UniverCollabEndpoint } from "@univerjs-pro/collaboration-endpoint";

const client = createClient({ url: process.env.REDIS_URL });
const subClient = client.duplicate();
await Promise.all([client.connect(), subClient.connect()]);

const pubSub = new RedisPubSubAdapter({ pubClient: client, subClient });
const ticketStore = new RedisSessionTicketStore({ client });
const endpoint = new UniverCollabEndpoint(service, { pubSub, ticketStore });
```

## Pour aller plus loin

Un très grand document ralentit les requêtes des petits documents du même nœud. Répartissez les nœuds en groupes selon la taille des documents et laissez la passerelle router les grands documents vers un groupe dédié ; la clé de routage reste l’unit ID et tous les groupes partagent la base de données et le pub/sub.