# Intégration continue

> Déployer depuis GitHub Actions, GitLab CI ou n'importe quel runner.

Le CLI est fait pour tourner sans personne devant : des jetons plutôt qu'une session,
`--yes` pour ne rien demander, `--json` pour être lu par un script, et un code de
sortie franc.

## Le jeton

Crée un jeton de portée **registre** si la chaîne ne fait que construire et déployer.
Même s'il fuit, personne ne supprime tes serveurs avec.

<Card title="Créer un jeton" icon="key" href="/commencer/jetons">
  Complet ou registre : ce que chacun autorise.
</Card>

Pose-le en secret, jamais en clair dans le fichier de configuration.

## Isoler les identifiants du runner

```bash
export ARKYA_HOME="$RUNNER_TEMP/arkya"
export ARKYA_TOKEN="$ARKYA_DEPLOY_TOKEN"
ark login --no-docker
```

`ARKYA_HOME` évite qu'un runner partagé écrive dans le dossier d'un autre travail.
`--no-docker` saute la connexion au registre quand le travail n'en a pas besoin ;
pour un déploiement, laisse-la faire.

## GitHub Actions

```yaml .github/workflows/deploy.yml
name: Déploiement

on:
  push:
    branches: [main]

jobs:
  deployer:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: 22

      - run: npm install -g @arkya/cli

      - name: Relier le compte
        env:
          ARKYA_HOME: ${{ runner.temp }}/arkya
          ARKYA_TOKEN: ${{ secrets.ARKYA_TOKEN }}
        run: ark login

      - name: Déployer
        env:
          ARKYA_HOME: ${{ runner.temp }}/arkya
        run: ark deploy --tag ${{ github.sha }}
```

Le nom de version vaut le commit : tu sais toujours quelle ligne de code tourne, et le
retour arrière est un `ark deploy --release <sha>`.

## GitLab CI

```yaml .gitlab-ci.yml
deployer:
  image: node:22
  services:
    - docker:dind
  variables:
    ARKYA_HOME: "$CI_PROJECT_DIR/.arkya"
    ARKYA_TOKEN: "$ARKYA_DEPLOY_TOKEN"
  script:
    - npm install -g @arkya/cli
    - ark login
    - ark deploy --tag "$CI_COMMIT_SHORT_SHA"
  only:
    - main
```

## Vérifier après le déploiement

```bash
ark status --json | jq -e '.status == "ACTIVE"'
ark logs --lines 50
```

`jq -e` sort en erreur si la condition est fausse : le travail échoue sans que tu aies
à écrire de test.

## Sauvegarder avant, depuis la chaîne

Pour un déploiement qui touche à des données :

```bash
ark backup create mon-api "ci-$CI_COMMIT_SHORT_SHA"
ark deploy --tag "$CI_COMMIT_SHORT_SHA"
```

## Une tâche planifiée plutôt qu'une chaîne

Une sauvegarde nocturne n'a pas besoin d'un runner. Une machine qui tourne déjà, une
ligne de `cron`, et le même CLI :

```cron
0 4 * * * ARKYA_HOME=/opt/arkya /usr/local/bin/ark backup create survie-2026 "nuit-$(date +\%Y\%m\%d)"
```

<Warning>
  Dans un `crontab`, les `%` doivent être échappés. C'est la cause numéro un des
  sauvegardes qui ne partent jamais.
</Warning>