---
title: Du code au conteneur
description: Le cycle code, Dockerfile, build, image, run et conteneur.
---

Le cycle de vie complet suit toujours le même enchaînement :

```text
code de l'application + Dockerfile
                │
                │ docker build
                ▼
              image
                │
                │ docker run
                ▼
            conteneur
```

<Steps>
  <Step>

  ### Versionner le code et le Dockerfile

  Le code et sa recette de construction vivent ensemble dans le dépôt.

  </Step>
  <Step>

  ### Construire l'image

  `docker build` lit le Dockerfile et exécute chaque instruction. Le résultat est une image figée et taguée.

  ```bash
  docker build -t mon-app/backend:1.4.0 .
  ```

  </Step>
  <Step>

  ### Instancier l'image

  `docker run`, ou `docker compose up`, lance un conteneur qui exécute la commande de démarrage.

  ```bash
  docker run --rm mon-app/backend:1.4.0
  ```

  </Step>
</Steps>

## Build et run sont deux opérations différentes

Le **build** produit une image, normalement une fois par version. Le **run** lance autant de conteneurs que nécessaire à partir de cette image.

## L'image reste immuable

Un conteneur peut écrire dans son propre système de fichiers. Ces écritures disparaissent lorsque le conteneur est détruit, sauf lorsqu'elles sont stockées dans un volume.

L'image d'origine, elle, ne change jamais.

## Le rôle de CMD

`CMD` indique le processus principal lancé au démarrage :

```dockerfile
CMD ["node", "dist/src/main"]
```

Dans cet exemple, le conteneur est le processus Node. Si ce processus s'arrête, le conteneur s'arrête.

<Callout title="Conséquence" type="info">
  Une image constitue l'artefact à livrer. Le conteneur n'est que son instance en cours d'exécution, avec une configuration et un état temporaires.
</Callout>
