# Applications conteneurisées

> init, build, push, deploy, status

Ces commandes concernent la gamme **ACS** : une image Docker que tu construis chez
toi et qu'Arkya met en service. Elles s'exécutent depuis ton dépôt, où elles lisent
un fichier `arkya.json`.

<Card title="Le guide complet" icon="rocket" href="/guides/deployer-une-application">
  Du premier `ark init` au déploiement continu.
</Card>

## ark init

Crée l'application chez Arkya s'il le faut, puis écrit `arkya.json` dans le dossier
courant.

```bash
ark init
ark init --app mon-api --node gra-01 --project Production
```

| Option | Ce qu'elle fait |
| --- | --- |
| `--app` | Le nom de l'application. Minuscules, chiffres et tirets. |
| `--node` | Le nœud qui l'héberge. Sans lui, la commande demande. |
| `--project` | Le projet de rattachement. Créé s'il n'existe pas encore. |
| `--dockerfile` | Le Dockerfile à construire. Par défaut `Dockerfile`. |
| `--context` | Le contexte de construction. Par défaut `.`. |
| `--force` | Écrase un `arkya.json` existant. |

```json arkya.json
{
  "app": "mon-api",
  "dockerfile": "Dockerfile",
  "context": ".",
  "node": "gra-01",
  "project": "Production",
  "env": {}
}
```

Le manifeste décrit aussi la puissance de l'application et ses prérequis — une base,
un cache. Voir [Le manifeste arkya.json](/cli/manifeste).

## ark plan

Compare le manifeste à ce qui existe vraiment, et dit ce qui manque.

```bash
ark plan
ark plan --apply
ark plan --apply --yes
```

```
mon-api Production

À créer :
  mon-api-db  postgres-16 · 1 vCPU · 2 Go · 20 Go   4.20 €/mois

À modifier :
  mon-api     2 vCPU · 2 Go · 20 Go (au lieu de 1 vCPU · 1 Go · 5 Go)
```

Sans `--apply`, la commande ne touche à rien.

## ark build

Construit l'image, pour l'architecture du nœud qui l'héberge.

```bash
ark build
ark build --tag v2
ark build --platform linux/arm64
```

Sans `--tag`, le nom de version est le commit courant (`git rev-parse --short=12`),
ou l'horodatage si le dossier n'est pas un dépôt Git.

## ark push

Envoie l'image au registre Arkya et enregistre la version.

```bash
ark push
ark push --tag v2
```

```
- envoi de registry.arkya.gg/c-7f3a91c04d2e/mon-api:8f2c1d9a44e0
- enregistrement de la version chez Arkya
ok version 8f2c1d9a44e0 disponible
sha256:2c8e…
- analyse de l'image
ok rien de sérieux dans cette image
```

Chaque image est analysée à la réception. Quand elle porte des failles sérieuses qui ne
regardent que ton application, `ark push` les liste et s'arrête là :

```
! 3 failles sérieuses dans cette image :
  CVE-2024-2511  openssl 3.0.11 → 3.0.13  High
  CVE-2024-4741  openssl 3.0.11 → 3.0.13  High
  CVE-2023-52425 expat 2.5.0 → 2.6.0  High
  Elles ne touchent que ton application — la mise en service suit son cours.
```

Quand la faille laisse sortir du conteneur, c'est un refus annoncé : la version est
poussée, mais elle ne sera pas mise en service.

```
! cette image ne pourra pas être mise en service :
  CVE-2024-21626  runc 1.1.5 → 1.1.12  Critical
  Ces failles laissent sortir du conteneur : elles ne regardent pas que toi.
```

## ark deploy

Applique le manifeste — création des prérequis, retaille — puis construit, envoie, pose
les variables et met en service. Ce qui doit être commandé est montré avec son prix, et
confirmé avant d'être créé.

```bash
ark deploy
ark deploy --tag v2
ark deploy --release 8f2c1d9a44e0
```

Une image dont l'analyse a trouvé de quoi sortir du conteneur ne part pas en service :

```
x Cette image ne peut pas être mise en service : CVE-2024-21626 dans runc 1.1.5
  (corrigé en 1.1.12). Ces failles laissent sortir du conteneur — reconstruis ton
  image sur une base à jour.
```

Rien n'est touché sur le nœud : l'application en place continue de tourner.

`--release` remet en service une version **déjà poussée**, sans reconstruire. C'est
le retour arrière :

```bash
ark status            # lire les versions
ark deploy --release 7a1b2c3d4e5f
```

```
- mise en service de mon-api:8f2c1d9a44e0
ok mon-api tourne en 8f2c1d9a44e0
  api.exemple.fr
```

## ark status

L'état de l'application et ses dernières versions.

```bash
ark status
ark status --all
```

```
Mon API (mon-api)
  état      ACTIVE
  image     registry.arkya.gg/c-7f3a91c04d2e/mon-api:8f2c1d9a44e0
  analyse   rien à signaler
  adresse   api.exemple.fr

versions
  8f2c1d9a44e0   en service               rien à signaler
  7a1b2c3d4e5f   poussée                  failles signalées
  6b0c9e8f7a6d   poussée                  non analysée
```

`--all` liste toutes tes applications plutôt que celle du dossier courant.

## Ce que ton image doit respecter

<Steps>
  <Step title="Écouter sur $PORT">
    Arkya pose la variable au démarrage, depuis le port que le nœud publie réellement.
  </Step>
  <Step title="Écrire dans /home/container">
    C'est le seul dossier qui survit au déploiement suivant.
  </Step>
  <Step title="Sortir proprement sur SIGTERM">
    C'est ce que `ark stop` et `ark restart` envoient.
  </Step>
</Steps>