---
title: Migrer depuis le POC
description: Importer les données d'une installation POC (SQLite) dans l'instance avec legacy:import, de la vérification préalable au retour arrière, puis basculer.
---

# Migrer depuis le POC

Si vous exploitiez la première version de 101Maintain, dite POC, avec sa base SQLite, vous pouvez importer son historique dans l'instance. L'import est hors ligne, vérifié et réversible tant que l'instance n'a pas d'activité propre.

**Qui peut le faire :** l'exploitant, avec un accès au serveur, à une copie de la base du POC et aux sauvegardes.

## Ce qui est importé

- Chaque dépôt du POC devient un projet et un dépôt rattaché. Un fichier de correspondance peut regrouper plusieurs dépôts dans un même projet.
- L'historique (exécutions, étapes, événements, audits, constats, accords passés) va dans des tables d'historique dédiées. Il reste consultable en SQL. Aucun worker ne le relit et aucun travail importé ne peut reprendre.
- Les usages et coûts sont convertis exactement. Un usage inconnu reste inconnu, jamais zéro.
- Un import rejoué retrouve les mêmes lignes : il est idempotent.

## Ce qui n'est pas importé

| Élément | Conséquence |
| --- | --- |
| Mot de passe partagé du POC | Chaque personne reçoit un compte nominatif, invité depuis l'écran **Utilisateurs**. L'import ne crée aucun compte. |
| Accords de recette actifs | Le Responsable crée un nouvel accord. L'ancien reste visible comme historique. |
| Surveillance des dépôts | Importée désactivée. Réactivez-la dépôt par dépôt. |
| Travaux en cours, reprises et files | Rien n'est mis en file. |
| Sessions, configuration et secrets du POC | À reconfigurer dans l'instance. |
| Exécutions du POC dans les écrans de maintenance | Elles restent dans les tables d'historique. |

## Préparer

1. L'instance est déployée, migrée, et le premier Administrateur existe. Voir [Premier administrateur et récupération](04-premier-administrateur-et-recuperation.md).
2. Créez sur l'hôte un dossier privé, propriété de l'UID 1000, droits 0700. Renseignez `LEGACY_IMPORT_DIR`.
3. Arrêtez le POC proprement, puis copiez son fichier `poc.sqlite` dans ce dossier. N'utilisez jamais le volume vivant du POC. Le journal d'écriture SQLite (`-wal`) doit être vide ou absent.
4. Facultatif : préparez un fichier de correspondance, sans secret :

```json
{
  "actors": { "libelle-poc": "personne@maintain.example" },
  "projects": {
    "atelier-exemple/site-vitrine": { "slug": "site-vitrine", "name": "Site vitrine" },
    "atelier-exemple/api": { "slug": "site-vitrine" }
  },
  "defaultCurrency": "EUR"
}
```

Une personne n'est associée à un historique que si son adresse correspond à un compte déjà invité ou actif.

## Les actions de la commande

Toutes les actions passent par le service `legacy-import` du profil `import`. Il utilise le rôle de migration, sans Redis ni accès réseau.

```bash
docker compose -p <projet> -f compose.mvp.yaml --env-file <env> --profile import run --rm legacy-import <action> <options>
```

| Action | Effet |
| --- | --- |
| `preflight --source /import/poc.sqlite` | Contrôle le fichier, l'intégrité, le schéma, le rôle et tous les écarts. N'écrit rien. |
| `backup --source /import/poc.sqlite --out /import/instantane` | Crée un instantané cohérent et son empreinte. |
| `dry-run --snapshot <instantané>` | Joue tout l'import et sa vérification, puis annule. |
| `apply --snapshot <instantané> --database-backup <référence>` | Importe dans une seule transaction. |
| `verify --snapshot <instantané>` | Compare la source et la base : lignes, empreintes, coûts. |
| `rollback --confirm` | Défait l'import. Sans `--confirm`, simple simulation. |

Ajoutez `--mapping /import/<fichier>.json` pour la correspondance, `--final` pour la bascule, et `--report /import/<rapport>.json` pour obtenir le rapport complet. Le code de sortie vaut 1 pour tout refus, et le rapport indique la raison dans le champ `refused`.

## Répéter jusqu'à un rapport propre

1. `preflight` avec `--report` : traitez chaque écart bloquant, relisez les avertissements.
2. `backup`, puis `dry-run`.
3. Sauvegardez la base avec `backup.sh`, puis `apply` en indiquant ce dossier de sauvegarde comme `--database-backup`.
4. `verify`.
5. Rejouez `apply` sur le même instantané : tout doit être inchangé.
6. Testez le retour arrière : `rollback`, puis `rollback --confirm`.

## Basculer

1. Annoncez une fenêtre d'indisponibilité. Vérifiez qu'aucune PR ni notification n'est en cours d'émission par le POC.
2. Arrêtez le POC. L'instance ne doit pas encore accepter d'écritures : worker arrêté.
3. Copiez `poc.sqlite`, créez l'instantané (`backup`) et sauvegardez la base de l'instance. Notez la référence.
4. `preflight --final`, puis `dry-run --final`.
5. `apply --final --database-backup <référence>`.
6. `verify` : la concordance doit être confirmée (`ready: true`).
7. Invitez les comptes, attribuez les rôles, relisez les responsables GitHub, créez les accords nécessaires, réactivez la surveillance dépôt par dépôt, puis démarrez le worker.
8. Conservez la base du POC intacte, en lecture seule, pendant toute la période de retour arrière possible.

## Revenir en arrière

> [!WARNING]
> `rollback --confirm` supprime les projets, dépôts et historiques créés par l'import. Il est refusé dès qu'un élément propre à l'instance dépend d'un dépôt importé (exécution, adhésion, audit, rapport…). Après mise en service, un retour au POC exige d'abord de recenser les effets déjà produits sur GitHub (PR brouillons, branches, commentaires, issues) et de laisser l'équipe du dépôt décider de leur sort.

Deux niveaux :

1. **Défaire l'import**, tant que l'instance n'a pas d'activité : `rollback --confirm`.
2. **Revenir au POC** après mise en service : traitez les effets externes, arrêtez l'instance, restaurez la sauvegarde ou défaites l'import, puis redémarrez le POC sur sa base restée intacte. Les écritures faites dans l'instance ne sont pas réinjectées dans le POC.

## Pour continuer

Retrouvez des scénarios complets au chapitre [Exemples de mise en place](../09-exemples-de-mise-en-place/01-installer-une-instance-de-zero.md).
