Scotty vs Laravel Envoy : notre retour terrain chez MulerTech

Le 30 mars dernier, Spatie a publié Scotty, un nouvel outil de déploiement SSH qui vient concurrencer directement Laravel Envoy. Chez MulerTech, nous déployons quotidiennement des applications Symfony sur des serveurs autogérés (VPS Hetzner, DigitalOcean), et la question s'est posée immédiatement : vaut-il la peine de migrer ? Voici notre retour pragmatique après quelques semaines d'utilisation.

Source originale : Scotty vs Laravel Envoy: Spatie's New Deploy Tool Is Worth the Switch par Hafiz sur DEV Community.

Ce qui coince avec Laravel Envoy au quotidien

Envoy est fonctionnel, personne ne le nie. Mais deux frictions reviennent systématiquement dès qu'on l'utilise en conditions réelles.

Le format Blade pour du shell. Le fichier Envoy.blade.php mélange des directives Blade (@task, @servers, @story) avec des commandes bash et des variables {{ $variable }}. Résultat : votre éditeur ne sait pas vraiment comment le traiter, le linting shell ne fonctionne pas à l'intérieur des blocs, et l'autocomplétion bash est inexistante. C'est un format hybride qui n'appartient pleinement ni au monde PHP ni au monde shell.

Le feedback terminal pendant l'exécution. Lorsqu'un déploiement tourne, Envoy affiche peu d'informations en temps réel. Sur un pipeline un peu long (migrations, cache:clear, assets), on se retrouve à attendre sans visibilité sur l'étape en cours. Ce n'est pas bloquant, mais c'est inconfortable en production.

Scotty répond précisément à ces deux points : syntaxe bash native et output terminal enrichi.

Migration pas-à-pas : de l'Envoy existant à Scotty

1. Installation

Scotty s'installe globalement via Composer :

composer global require spatie/scotty

Assurez-vous que ~/.composer/vendor/bin est dans votre $PATH.

2. Structure du fichier de déploiement

Là où Envoy utilise un fichier .blade.php, Scotty utilise un fichier scotty.php en PHP pur. Voici un exemple concret adapté à un projet Symfony :

<?php

use Spatie\Scotty\Scotty;

$scotty = Scotty::configure()
    ->host('deploy@mon-serveur.example.com')
    ->path('/var/www/mon-app');

$scotty->task('deploy', function () use ($scotty) {
    $scotty->run('git pull origin main');
    $scotty->run('composer install --no-dev --optimize-autoloader');
    $scotty->run('php bin/console doctrine:migrations:migrate --no-interaction');
    $scotty->run('php bin/console cache:clear --env=prod');
    $scotty->run('php bin/console cache:warmup --env=prod');
});

C'est du PHP valide, votre IDE le comprend entièrement, le linting fonctionne, et les variables sont des variables PHP ordinaires.

3. Gestion des secrets

Avec Envoy, les secrets passaient souvent par des variables d'environnement lues via {{ env('MY_SECRET') }}. Avec Scotty, la logique est identique mais plus lisible :

$dbPassword = getenv('DB_PASSWORD');

$scotty->task('backup', function () use ($scotty, $dbPassword) {
    $scotty->run("mysqldump -u root -p{$dbPassword} ma_base > backup.sql");
});

Pour l'intégration CI/CD (GitHub Actions, GitLab CI), injectez vos secrets en variables d'environnement du pipeline, exactement comme vous le faisiez avec Envoy. Rien ne change côté configuration des secrets.

4. Rollback : une tâche dédiée

Le rollback est souvent la partie négligée des scripts de déploiement. Avec Scotty, on peut structurer une tâche rollback proprement :

$scotty->task('rollback', function () use ($scotty) {
    $scotty->run('git checkout HEAD~1');
    $scotty->run('composer install --no-dev --optimize-autoloader');
    $scotty->run('php bin/console doctrine:migrations:migrate --no-interaction');
    $scotty->run('php bin/console cache:clear --env=prod');
});

Pour des stratégies de rollback plus robustes (symlinks, releases), Scotty ne fournit pas de scaffolding intégré comme Deployer. Il faut le coder soi-même, ce qui est à la fois sa force (flexibilité totale) et sa limite (pas de convention prête à l'emploi).

Intégration CI/CD : GitHub Actions en exemple

Voici comment invoquer Scotty dans un workflow GitHub Actions :

name: Deploy

on:
  push:
    branches: [main]

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

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.3'

      - name: Install Scotty
        run: composer global require spatie/scotty

      - name: Configure SSH
        run: |
          mkdir -p ~/.ssh
          echo "${{ secrets.SSH_PRIVATE_KEY }}" > ~/.ssh/id_rsa
          chmod 600 ~/.ssh/id_rsa
          ssh-keyscan mon-serveur.example.com >> ~/.ssh/known_hosts

      - name: Deploy
        run: scotty run deploy
        env:
          DB_PASSWORD: ${{ secrets.DB_PASSWORD }}

La configuration SSH reste identique à ce que vous faisiez avec Envoy. Scotty ne change rien à cette mécanique.

Comparaison pragmatique : Scotty, Envoy, ou solution managée ?

Pour les TPE/PME que nous accompagnons chez MulerTech, la question du choix de l'outil de déploiement se pose souvent en ces termes :

Notre position chez MulerTech : pour les projets Symfony sur serveurs autogérés avec une équipe technique en place, Scotty est un choix solide. Il élimine la friction du format Blade et améliore l'expérience de déploiement sans ajouter de complexité. Pour les clients sans ressources DevOps internes, une solution managée comme Forge reste plus adaptée. Scotty n'est pas un remplacement de Deployer non plus : si vous avez besoin de déploiements atomic avec symlinks et gestion des releases, Deployer reste la référence PHP.

Conclusion

Scotty n'est pas une révolution, mais c'est une évolution bien pensée. Il résout deux irritants réels d'Envoy (syntaxe hybride, feedback pauvre) sans introduire de nouvelle complexité. La migration depuis Envoy est rapide pour une équipe PHP : le fichier scotty.php est du PHP que votre IDE comprend immédiatement.

Chez MulerTech, nous l'avons intégré sur plusieurs projets Symfony en production et le bilan est positif. Si vous êtes sur des serveurs autogérés et que vous maintenez des scripts Envoy, prenez 30 minutes pour tester Scotty : la différence au quotidien est tangible.