Introduction

GitLab Runner est un projet open source qui est utilisé pour exécuter vos travaux et renvoyer les résultats à votre plateforme GitLab. Il est utilisé en conjonction avec GitLab CI/CD, le service d'intégration continue open-source inclus avec GitLab qui coordonne les travaux.

Pré-requis

GitLab Runner est écrit en Go et peut être exécuté comme un binaire unique.

Il est conçu pour fonctionner sur les systèmes d'exploitation GNU/Linux, macOS et Windows. Les autres systèmes d'exploitation fonctionneront probablement tant que vous pourrez compiler un binaire Go sur eux.

Si vous voulez utiliser Docker, installez la dernière version.

GitLab Runner nécessite un minimum de Docker v1.13.0.

Caractéristiques

  • Permet :
    • Executer plusieurs jobs simultanément.
    • Utiliser plusieurs jetons avec plusieurs serveurs (même par projet).
    • Limiter le nombre de jobs simultanés par jeton.
  • Les travaux peuvent être exécutés :
    • Localement.
    • En utilisant des conteneurs Docker.
    • Utilisation de conteneurs Docker et exécution de tâches par SSH.
    • Utilisation de conteneurs Docker avec mise à l'échelle automatique sur différents cloud et hyperviseurs de virtualisation.
    • Connexion à un serveur SSH distant.
  • Est écrit en Go et distribué en binaire unique sans autre exigence.
  • Prend en charge Bash et Windows PowerShell.
  • Fonctionne sous GNU/Linux, macOS et Windows (à peu près partout où vous pouvez utiliser Docker).
  • Permet la personnalisation de l'environnement d'exécution du job.
  • Rechargement automatique de la configuration sans redémarrage.
  • Configuration facile à utiliser avec prise en charge des environnements d'exécution Docker, Docker-SSH, Parallels ou SSH.
  • Permet la mise en cache des conteneurs Docker.
  • Installation facile en tant que service pour GNU/Linux, macOS et Windows.
  • Serveur HTTP de métrologie Prometheus intégré.

Compatibilité avec les versions de GitLab

La version GitLab Runner doit être synchronisée avec la version GitLab. Bien que les anciens Runners puissent toujours fonctionner avec les nouvelles versions de GitLab, et vice versa, dans certains cas, des fonctionnalités peuvent ne pas être disponibles ou fonctionner correctement s'il y a une différence de version.

La rétrocompatibilité est garantie entre les mises à jour de versions mineures, mais sachez que les mises à jour de versions mineures de GitLab peuvent introduire de nouvelles fonctionnalités qui nécessiteront que le Runner soit sur la même version mineure.

Installer le GitLab Runner

GitLab Runner peut être installé et utilisé sur GNU/Linux, macOS, FreeBSD et Windows. Vous pouvez l'installer à l'aide du Docker, télécharger le binaire manuellement ou utiliser le dépôt de paquets rpm/deb que GitLab propose.

Nous allons dans notre cas déployer le gitlab-runner sur une distribution Linux.

Pour installer le Runner :

Ajoutez le dépôt officiel du GitLab : 

# For Debian/Ubuntu/Mint
curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh | sudo bash
 
# For RHEL/CentOS/Fedora
curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.rpm.sh | sudo bash

Installez la dernière version de GitLab Runner, ou passez à l'étape suivante pour installer une version spécifique : 

# Pour Debian/Ubuntu/Mint
sudo apt-get install gitlab-runner
 
# Pour RHEL/CentOS/Fedora
sudo yum install gitlab-runner

Mise à jour du Runner

Il suffit de l'exécuter pour installer la dernière version : 

# Pour Debian/Ubuntu/Mint
sudo apt-get install gitlab-runner
 
# Pour RHEL/CentOS/Fedora
sudo yum install gitlab-runner

Enregistrement des Runners

L'enregistrement d'un Runner est le processus qui lie le Runner à une instance GitLab.

Pour enregistrer un Runner sous GNU/Linux :

Exécutez la commande suivante : 

sudo gitlab-runner register

Entrez l'URL de votre instance GitLab : 

Please enter the gitlab-ci coordinator URL (e.g. https://gitlab.com/):
http://gitlab.oowy.fr

Saisissez le jeton que vous avez obtenu pour inscrire le coureur : 

Please enter the gitlab-ci token for this runner:
u7cQyssKyWHyUrdd-c-A

Entrez une description pour le Runner, vous pourrez la modifier plus tard dans l'interface utilisateur du GitLab : 

Please enter the gitlab-ci description for this runner:
[runner]: Generic Runner

Veuillez entrer les balises gitlab-ci pour ce runner 

Please enter the gitlab-ci tags for this runner (comma separated):

Entrez l'exécuteur testamentaire du coureur : 

Please enter the executor: docker+machine, docker-ssh+machine, shell, ssh, docker-ssh, parallels, virtualbox, kubernetes, custom, docker:
shell

Fin de la configuration du runner : 

Runner registered successfully. Feel free to start it, but if it's running already the config should be automatically reloaded!

Gitlab Runner in Docker

# docker run -d --name gitlab-runner --restart always \
   -v /srv/gitlab-runner/config:/etc/gitlab-runner \
   -v /var/run/docker.sock:/var/run/docker.sock \
   gitlab/gitlab-runner:latest

Enregistrement 

[user@docker ~]$ docker run --rm -it -v /srv/gitlab-runner/config:/etc/gitlab-runner gitlab/gitlab-runner register
Runtime platform                                    arch=amd64 os=linux pid=8 revision=943fc252 version=13.7.0
Running in system-mode.
 
Enter the GitLab instance URL (for example, https://gitlab.com/):
https://gitlab.oowy.fr
Enter the registration token:
4qD5Erkb9x3py15CMjSs
Enter a description for the runner:
[f0e9ac1fff98]: Docker-Runner
Enter tags for the runner (comma-separated):
 
Registering runner... succeeded                     runner=4qD5Erkb
Enter an executor: docker, docker-ssh, parallels, shell, ssh, virtualbox, docker-ssh+machine, custom, kubernetes, docker+machine:
docker
Enter the default Docker image (for example, ruby:2.6):
ruby:2.6
Runner registered successfully. Feel free to start it, but if it's running already the config should be automatically reloaded!

Une fois le runner enregistré, celui-ci remonte dans gitlab

Gitlab Runner in Kubernetes

Ajouter le repository helm de gitlab. 

bastion:~$ helm repo add gitlab https://charts.gitlab.io

Une fois que nous aurons configuré GitLab Runner dans un fichier values.yaml, nous exécuterons ce qui suit : 

bastion:~$ helm install --namespace <NAMESPACE> gitlab-runner -f <CONFIG_VALUES_FILE> gitlab/gitlab-runner

Où :

  • <NAMESPACE> est l'espace de nom Kubernetes dans lequel vous souhaitez installer le Runner GitLab.
  • <CONFIG_VALUES_FILE> est le chemin d'accès au fichier de valeurs contenant votre configuration personnalisée.

Note:

Si l'on souhaite installer une version spécifique du Helm charts du GitLab Runner, ajoutez –version <RUNNER_HELM_CHART_VERSION>.

Création d'un fichier values.yaml avec les informations nécessaires pour que gitlab-runner se rattache à la plateforme gitlab 

bastion:~$ nano values.yaml
gitlabUrl: https://gitlab.oowy.fr/
runnerRegistrationToken: drJDdsg2js3LdBJED29d
concurrent: 20
rbac:
  create: true
  clusterWideAccess: false
runners:
  image: ubuntu:18.04
  privileged: false
  builds:
    memoryRequests: 1000Mi

On créer le namespace gitlab-runner si ce dernier n'existe pas 

bastion:~$ kubectl create ns gitlab-runner

On déploie le gitlab-runner 

bastion:~$ helm install --namespace gitlab-runner gitlab-runner -f values.yaml gitlab/gitlab-runner

Création du fichier .gitlab-ci.yml

Votre dépôt gitlab est créé, vous avez cloner celui-ci, vous pouvez maintenant créer votre configuration.

Le fichier .gitlab-ci.yml est l'endroit ou vous allez configurer votre processus d'intégration continue. Il se place à la racine de votre projet.

A chaque push, GitLab va regarder dans ce fichier et lancer les tâches dans le Runner précédemment créer.

Je vous invite à créer ce fichier à la racine de votre projet et coller le contenu suivant : 

build-job:
  stage: build
  script:
    - echo "Hello, $GITLAB_USER_LOGIN!"
 
test-job1:
  stage: test
  script:
    - echo "This job tests something"
 
test-job2:
  stage: test
  script:
    - echo "This job tests something, but takes more time than test-job1."
    - echo "After the echo commands complete, it runs the sleep command for 20 seconds"
    - echo "which simulates a test that runs 20 seconds longer than test-job1"
    - sleep 20
 
deploy-prod:
  stage: deploy
  script:
    - echo "This job deploys something from the $CI_COMMIT_BRANCH branch."

Cette configuration créée 3 jobs : build, test et deploy. Ces jobs (=tâches) ne font rien à part écrire du texte.

Plus tard vous pourrez mettre toutes vos commandes comme “apt install, npm install, phpunit, gulp …”

On commit puis push le fichier : 

git add .gitlab-ci.yml
git commit -m "Add .gitlab-ci.yml"
git push origin master

Sur l'interface GitLab, dans votre projet / CI/CD / Pipelines :

Annexe

https://docs.gitlab.com/

https://docs.gitlab.com/runner/

https://docs.gitlab.com/runner/commands/#gitlab-runner-uninstall

https://docs.gitlab.com/ee/ci/runners/#shared-runners

https://docs.gitlab.com/runner/install/docker.html

https://docs.gitlab.com/runner/register/index.html#docker

https://docs.gitlab.com/runner/install/kubernetes.html

https://gitlab.com/gitlab-org/charts/gitlab-runner/-/blob/master/values.yaml

https://docs.gitlab.com/ee/ci/docker/using_docker_build.html

Ce site web utilise des cookies. En utilisant le site Web, vous acceptez le stockage de cookies sur votre ordinateur. Vous reconnaissez également que vous avez lu et compris notre politique de confidentialité. Si vous n'êtes pas d'accord, quittez le site.En savoir plus