Configuration avancée des Runners GitLab via config.toml

Maîtrisez le fichier de configuration des Runners GitLab pour gérer le parallélisme, les executors et la sécurité.

Configuration des Runners (Executors & config.toml)

Comprendre le concept d'Executor

Lorsque vous enregistrez un GitLab Runner, la question la plus importante qui vous est posée est le choix de l'Executor (l'exécuteur). Le Runner n'est que le messager, l'Executor est l'environnement réel dans lequel votre code va s'exécuter.

Trois exécuteurs dominent le marché DevOps :

  • Shell : Le code s'exécute directement sur la machine hôte du Runner. Très rapide, mais dangereux car les dépendances s'accumulent sur le serveur et les jobs peuvent interférer entre eux.
  • Docker : L'exécuteur standard et incontournable. Chaque job démarre dans un conteneur vierge et isolé, garantissant que "ça marche sur ma machine ET sur le serveur".
  • Kubernetes : Pour les infrastructures massives. Le Runner crée dynamiquement des "Pods" sur un cluster Kubernetes pour exécuter les jobs, offrant une scalabilité infinie.

Plongée dans le fichier config.toml

La véritable puissance d'un administrateur se trouve dans la configuration sous-jacente du Runner. Sous Linux, ce fichier se trouve généralement dans /etc/gitlab-runner/config.toml. C'est ici que vous définissez la capacité de charge de votre machine.

Augmenter la concurrence (Parallélisme)

Par défaut, un Runner n'exécute qu'un seul job à la fois. Si vous avez une machine puissante (ex: 8 cœurs, 32 Go de RAM), c'est un énorme gâchis. La variable globale concurrent permet d'augmenter cette limite.

# /etc/gitlab-runner/config.toml
concurrent = 4
check_interval = 3
log_level = "info"

[[runners]]
  name = "Docker-Runner-Production"
  url = "https://gitlab.com/"
  token = "glrt-XxYyZz1234"
  executor = "docker"
  [runners.docker]
    tls_verify = false
    image = "alpine:latest"
    privileged = false
    disable_entrypoint_overwrite = false
    oom_kill_disable = false
    disable_cache = false
    volumes = ["/cache"]
    shm_size = 0

Explication des paramètres critiques :

  • concurrent = 4 : Ce Runner peut maintenant traiter jusqu'à 4 jobs de n'importe quel projet simultanément.
  • check_interval = 3 : Le Runner demandera à GitLab s'il y a du nouveau travail toutes les 3 secondes.
  • volumes = ["/cache"] : Indispensable pour que le système de cache (comme les dépendances Node.js ou Maven) persiste entre deux exécutions de conteneurs.

Le mode "Privileged" : Puissance et Danger

Dans la section [runners.docker], vous remarquerez le paramètre privileged = false. Si vous le passez à true, le conteneur exécutant votre job aura un accès quasi-complet au système hôte.

Alerte Sécurité (DevSecOps)

Activer le mode privilégié est souvent nécessaire pour exécuter Docker dans Docker (DinD), mais c'est un risque de sécurité majeur sur un Runner partagé. Ne l'activez que sur des Runners spécifiques dédiés à des projets de confiance. On lui préfère des alternatives "Daemonless" comme Kaniko.

Appliquer les modifications

Contrairement à beaucoup de services Linux, il n'est pas toujours nécessaire de redémarrer brutalement le Runner après une modification du config.toml. Le processus lit le fichier régulièrement. Cependant, pour forcer la prise en compte immédiate, utilisez la commande :

sudo gitlab-runner restart

Conclusion

Maîtriser les Executors et le fichier de configuration config.toml vous permet de transformer une simple machine de calcul en une flotte de Runners taillés sur mesure pour votre architecture.

Maintenant que vos moteurs tournent à plein régime, il est temps d'écrire des partitions plus complexes. Dans le chapitre suivant, nous allons explorer les mots-clés avancés du fichier .gitlab-ci.yml.

Espace commentaire

Écrire un commentaire

Rejoignez la discussion

Vous devez être connecté pour poster un message.

15 commentaires

amace
Membre
Avatar de amace
amace
Membre

Super récap. Le fait de distinguer bien Executor vs Runner est souvent le point aveugle des juniors. C'est la base, faut pas négliger ça.

16/05/2026 à 15:32
roland33
Membre Actif
Avatar de roland33
roland33
Membre Actif

Trop important le point sur volumes = ["/cache"]. Sans ça, les dépendances Node.js repartent de zéro à chaque run, c'est une torture en CI.

On a eu le même souci avec des gros caches Maven, on a dû optimiser la persistance des volumes à l'extérieur du Pod pour vraiment scaler.

Modifié le 23/05/2026 à 16:20

Le concurrent setting est crucial. Sur nos machines de build de 16 cores, on le booste à 8 minimum. Si vous laissez à 1, vous payez pour des ressources inutilisées.

Modifié le 23/05/2026 à 16:20
guy-hebert
Membre
Avatar de guy-hebert
guy-hebert
Membre

Petit rappel de sécurité : ne jamais mettre privileged = true en production, point final. Même si c'est juste pour faire du DinD, ça ouvre trop de surface d'attaque. Préférez Kaniko ou BuildKit.

Modifié le 23/05/2026 à 16:20
martine91
Membre Actif
Avatar de martine91
martine91
Membre Actif

On utilise K8s comme executor, mais la gestion du config.toml est un vrai casse-tête pour les conteneurs dynamiques. Si vous mettez concurrent trop haut sans backend K8s robuste, vous allez saturer l'API du cluster.

Modifié le 23/05/2026 à 16:20
robin-noel
Membre
Avatar de robin-noel
robin-noel
Membre

Question de workflow : quand le cache est monté sur un volume partagé, est-ce que ce volume persisté est propre à l'image, ou est-ce un état global ? Car si on déploie un alpine:latest différent, on veut être sûr que le cache de la première exécution n'impacte pas la seconde.

Modifié le 23/05/2026 à 16:20
aimee89
Membre
Avatar de aimee89
aimee89
Membre

Gros point sur l'intervalle de check (check_interval). 3s c'est OK pour un lab, mais en production avec des milliers de runners, vous pouvez vouloir le monter à 5s ou 10s pour réduire la charge sur l'API GitLab et les runners elles-mêmes.

Modifié le 23/05/2026 à 16:20
mallet-thomas
Membre Actif Secouriste
Avatar de mallet-thomas
mallet-thomas
Membre Actif Secouriste

Ok, sudo gitlab-runner restart marche, mais si vous utilisez un système de gestion de service comme Systemd, le plus propre est souvent de taper systemctl reload gitlab-runner pour s'assurer que toutes les dépendances sont correctement rechargées.

Modifié le 23/05/2026 à 16:20
colette-jacquet
Membre Actif Secouriste
Avatar de colette-jacquet
colette-jacquet
Membre Actif Secouriste

Le danger du mode Shell est sous-estimé. Les variables globales de l'hôte s'accumulent vite, vous allez vous retrouver avec une

Modifié le 23/05/2026 à 16:20

dépendance fantôme` installée globalement qui va planter le job suivant, même s'il est censé être isolé. Docker résout ça, mais il faut rester vigilant sur le montage des volumes hôtes si on s'éloigne du standard.

16/05/2026 à 15:32
charlotte93
Membre
Avatar de charlotte93
charlotte93
Membre

Confirme l'utilisation de disable_entrypoint_overwrite = false. On doit absolument pouvoir utiliser notre propre ENTRYPOINT custom pour initialiser l'environnement de build avant le script CI.

Modifié le 23/05/2026 à 16:20
frederic94
Membre
Avatar de frederic94
frederic94
Membre

Pour les gros clusters, il faut séparer les runners par fonction dans le config.toml. Un pool pour les builds légers, un autre, isolé, pour les tests de sécurité (SAST/DAST) qui peuvent être plus gourmands et nécessitent des dépendances spécifiques.

Modifié le 23/05/2026 à 16:20
acoste
Membre
Avatar de acoste
acoste
Membre

Alerte Sécurité DevSecOps : le passage au mode privilégié est un vrai fallacy. Au lieu d'accepter le risque, séparez le Runner sur une VM dédiée, dans un réseau privé, et limitez strictement les capacités CAP_SYS_ADMIN si possible.

Modifié le 23/05/2026 à 16:20
gerard54
Membre
Avatar de gerard54
gerard54
Membre

Quand vous parlez de volumes = ["/cache"], parlez-vous bien de volumes de type bind mount ou des volumes nommés Docker ? Ça change le niveau d'isolation et de gestion des permissions, ce qui est critique si plusieurs services doivent y écrire.

Modifié le 23/05/2026 à 16:20

Petite note sur shm_size = 0. C'est souvent une source de bugs en CI si les outils (comme certains compilateurs ou outils Python/data science) ont besoin de la mémoire partagée pour le build. Testez avec 64mb au lieu de 0 si vous avez des artefacts lourds.

Modifié le 23/05/2026 à 16:20

Rejoindre la communauté

Recevoir les derniers articles gratuitement en créant un compte !

S'inscrire