Aller au contenu principal

Monorepo CI/CD

Un monorepo est un repository unique qui contient le code de plusieurs projets ou services. Au lieu d'avoir un repo par application, tout vit dans le même dépôt — ce qui simplifie le partage de code et la cohérence entre services.

Fransys supporte le déploiement de plusieurs applications depuis un seul repository, avec un peu de configuration manuelle côté CI. Ce guide vous accompagne étape par étape.

Scénario​

Nous allons configurer un monorepo sur Fransys avec GitHub Actions pour la CI/CD. Le repository contient deux applications — App A et App B — organisées en sous-dossiers.

Nous créerons deux blocs applicatifs Fransys (un par app) connectés au même repo GitHub, avec un workflow CI dédié pour chacun.

astuce

Ce guide utilise GitHub, mais la même logique s'applique à GitLab.

Structure du monorepo​

Prenons comme exemple le repository tutorial-fransys/monorepo-example :

monorepo-example/
└── apps/
    ├── app-a/
    │   └── Dockerfile
    └── app-b/
        └── Dockerfile

Chaque sous-dossier contient le code source et un Dockerfile. Fransys déploiera chaque app comme un bloc séparé via son propre Dockerfile.

Étape 1 — Créer le Block A dans Fransys​

  1. Connectez-vous au dashboard Fransys et naviguez vers votre projet
  2. Ajoutez un nouveau bloc Docker pour App A
  3. Donnez-lui un nom clair (ex : "App A" ou "app-a")

Étape 2 — Lier le repository GitHub au Block A​

Dans la configuration du bloc, choisissez GitHub comme source, sélectionnez votre repo monorepo et la branche souhaitée.

Une fois le lien créé, cliquez sur Open merge request et rendez-vous sur GitHub.

Étape 3 — Configurer le workflow CI pour App A​

Sur votre repository GitHub, deux choses à faire :

Ajouter la variable Dockerfile path​

Dans votre repo GitHub, allez dans Settings > Secrets and variables > Actions. Sous "Repository variables", créez une variable :

  • Nom : DOCKERFILE_PATH_APP_A
  • Valeur : app-a/Dockerfile

Cette variable indique au workflow quel Dockerfile builder pour le Block A.

Modifier le workflow CI​

Ouvrez le fichier workflow GitHub Actions généré par Fransys (ex : .github/workflows/fransys.yml). Trouvez le snippet suivant (autour de la ligne 24) :

run: |
  if [[ -z "${{ vars.DOCKERFILE_PATH }}" ]]; then
    echo "DOCKERFILE_PATH=Dockerfile" >> $GITHUB_OUTPUT
  else
    echo "DOCKERFILE_PATH=${{ vars.DOCKERFILE_PATH }}" >> $GITHUB_OUTPUT
  fi

Remplacez DOCKERFILE_PATH par DOCKERFILE_PATH_APP_A :

run: |
  if [[ -z "${{ vars.DOCKERFILE_PATH_APP_A }}" ]]; then
    echo "DOCKERFILE_PATH=Dockerfile" >> $GITHUB_OUTPUT
  else
    echo "DOCKERFILE_PATH=${{ vars.DOCKERFILE_PATH_APP_A }}" >> $GITHUB_OUTPUT
  fi

Renommez le fichier en fransys_app_a.yml pour le distinguer, puis commitez sur la branche de la pull request.

Étape 4 — Tester le workflow​

Sur GitHub, allez dans l'onglet Actions et vérifiez que le build passe correctement.

Si le build échoue, vérifiez les logs — les causes les plus fréquentes sont un chemin de Dockerfile incorrect ou des permissions manquantes. Corrigez et relancez jusqu'à ce que le pipeline passe.

Étape 5 — Vérifier le déploiement du Block A​

Une fois le workflow GitHub Actions réussi, retournez sur Fransys. Dans les détails du Block A, vous devriez voir le dernier commit de votre repository. Fransys lie chaque déploiement à un commit Git — confirmez que le Block A utilise bien la dernière image.

App A est configurée et déployée via CI/CD.

Étape 6 — Répéter pour le Block B​

Suivez le même processus pour App B :

  1. Créer le Block B dans Fransys — Ajoutez un nouveau bloc Docker nommé "App B" ou "app-b", lié au même repository monorepo

  2. Ajouter la variable DOCKERFILE_PATH_APP_B dans les repo variables GitHub avec la valeur app-b/Dockerfile

  3. Modifier le workflow CI — Le lien du bloc avec GitHub va générer un nouveau fransys.yml. Modifiez-le pour utiliser DOCKERFILE_PATH_APP_B et renommez-le en fransys_app_b.yml

  4. Tester et vérifier — Vérifiez que le workflow passe dans GitHub Actions, puis confirmez sur Fransys que le Block B détecte le dernier commit

Étape 7 — Déployer​

Vous avez maintenant deux blocs correctement configurés depuis le même repository. Déployez-les sur le cluster de votre choix.

Conseils​

  • Vérifiez les chemins — Les variables DOCKERFILE_PATH_APP_A et DOCKERFILE_PATH_APP_B doivent correspondre exactement aux chemins de vos Dockerfiles. Une faute de frappe = un build en échec.
  • Surveillez les logs CI — À chaque push ou pull request, vérifiez les logs GitHub Actions pour détecter les erreurs tôt.
  • Confirmez sur Fransys — Après un build réussi, vérifiez que chaque bloc affiche bien le dernier commit et le timestamp de déploiement.
  • Auto-deploy activé par défaut — Les deux blocs sont en auto-deploy : tout changement sur le repo déploie automatiquement la nouvelle version si le bloc est déjà online.