Déployer un Gitlab runner sur Kubernetes
Écrit par
Publié le
Do not index
Do not index
Primary Keyword
Lié à Analyse sémantique (Articles liés) 1
Lié à Analyse sémantique (Articles liés)
Statut rédaction
A optimiser SEO
Lié à Analyse sémantique (Articles liés) 2
Introduction au Gitlab RunnerPrésentation Gitlab Prérequis pour installer le Gitlab RunnerTerraformHelmKubernetesConfiguration Gitlab RunnerConfiguration Chart Gitlab RunnerIntégration TerraformDéploiement du Gitlab RunnerCréation pipeline Gitlab pour réaliser la CI / CDConclusion
Introduction au Gitlab Runner
Nul ne peut nier que les runners de CI / CD sont des composants clés du processus de livraison continue, permettant aux équipes de développement de livrer rapidement et régulièrement des logiciels de haute qualité. Cependant, ces runners peuvent présenter plusieurs problématiques, notamment en termes de performance, de coûts, de complexité de configuration et de sécurité. Il est donc important de prendre en compte ces problématiques lors de la mise en place et de la gestion de runners de CI / CD, afin de garantir la qualité et la fiabilité du processus de livraison continue. Cela peut être réalisé en utilisant des runners personnalisés bien configurés.
Dans cet article, nous allons configurer une pipeline CI / CD ainsi que son Runner qui utilisera l’éxécuteur Kubernetes.
Présentation Gitlab
GitLab est un outil émergent qui renforce l'un des piliers de DevOps appelé CI / CD Pipeline. Tout comme nous avons des exécuteurs dans Jenkins, GitLab a des Runners qui agissent comme une application à la demande et exécutent les instructions définies dans les scripts GitLab Pipeline à la racine du projet.
Prérequis pour installer le Gitlab Runner
Terraform
Terraform est un outil open source qui permet la gestion programmable et reproductible des ressources d'infrastructure. Nous allons l'utiliser pour configurer le Runner de la pipeline CI / CD dans Gitlab en utilisant Helm pour la configuration du cluster Kubernetes.
Helm
Helm est un outil open source de gestion de packages pour Kubernetes. Il permet de déployer, de gérer et de mettre à jour des applications sur un cluster Kubernetes en utilisant des charts, qui sont des packages préconfigurés contenant les fichiers de configuration, les dépendances et les templates nécessaires pour déployer une application.
Kubernetes
Kubernetes est une plateforme open-source d'orchestration de conteneurs pour la gestion automatisée de déploiement, de mise à l'échelle et de gestion des applications conteneurisées dans des environnements de cloud computing ou sur site.
Configuration Gitlab Runner
Configuration Chart Gitlab Runner
Dans ce tutoriel nous allons utiliser la chart Gitlab Runner pour la configuration de notre Runner, téléchargez le fichier
values.yml et modifiez la configuration suivante:#Pour plus d'informations, visitez https://docs.gitlab.com/runner/install/kubernetes.html
config: |
[[runners]]
[runners.kubernetes]
namespace = "{{.Release.Namespace}}"
image = "flawnrayen/docker-runner:latest"
privileged = true
[[runners.kubernetes.volumes.empty_dir]]
name = "docker-certs"
mount_path = "/certs/client"
medium = "Memory"Cette configuration permet:
- La configuration de l’image qui va être éxécutée dans le Runner Kubernetes à
flawnrayen/docker-runner.
- L’éxécution en mode priviligée pour garantir la fonctionnement du service Docker.
- Le montage d’un volume pour stocker le certificat de Docker dans la mémoire.
Intégration Terraform
Créez le fichier
main.tf contenant le code suivant:provider "helm" {
kubernetes {
config_path = "<PATH-TO-KUBECONFIG-FILE>"
}
}
resource "helm_release" "gitlab-runner" {
name = "gitlab-runner"
repository = "https://charts.gitlab.io"
chart = "gitlab-runner"
values = [
"${file("<PATH-TO-VALUES-FILE>")}"
]
}Cette configuration permet:
- L’authentification du cluster Kubernetes en utilisant le provider
Kuberneteset le fichierkubeconfig
- La création d’une ressource Helm
"gitlab-runner"en utilisant le répertoire de Gitlab et la chart"gitlab-runner"
Vous pouvez ainsi lock les versions des providers utilisés pour garantir le bon fonctionnement de ce tutoriel en créant le fichier
version.tf contenant le code suivant:terraform {
required_providers {
helm = {
source = "hashicorp/helm"
version = "2.8.0"
}
kubernetes = {
source = "hashicorp/kubernetes"
version = "2.17.0"
}
}
required_version = "~> 1.3"
}Déploiement du Gitlab Runner
Pour linker le cluster Kubernetes avec le projet dont vous voulez avoir un Runner vous devez s’authentifier.
Ainsi devez allez à
<VOTRE_REPERTOIRE> > Paramètres > CI/CD > Runners et copiez le jeton d’enregistrement. Ensuite créez le fichier registration-token-secret.yml qui va contenir le jeton qu’on vient d’obtenir. apiVersion: v1
kind: Secret
metadata:
name: gitlab-runner
namespace: default
type: Opaque
stringData:
runner-registration-token: "<JETON_ENREGISTREMENT>"
runner-token: ""Ce fichier crée un secret dans le cluster qui va être utilisé pour la communication et l’enregistrement du cluster en tant que Runner du projet.
Après la création du fichier appliquez la commande suivante:
kubectl apply -f registration-token-secret.yml Une fois que la configuration est bien set et le secret créé, exécutez en passant les commandes suivantes:
terraform init
terraform plan
terraform apply
Création pipeline Gitlab pour réaliser la CI / CD
Après avoir mis en place le Runner, nous pouvons maintenant créer une pipeline CI / CD pour automatiser le processus de l’intégration et déploiement de notre application.
Vous pouvez créer le fichier
gitlab-ci.yml sous la racine du projet qui contient le code suivant:stages:
- test
- build
- release
variables:
DOCKER_HOST: tcp://docker:2376
DOCKER_TLS_CERTDIR: "/certs"
DOCKER_TLS_VERIFY: 1
DOCKER_CERT_PATH: "$DOCKER_TLS_CERTDIR/client"
before_script:
- <TRAITEMENT_GLOBAL> # Traitement indépendant des stages tel que l'installation des dépendances (npm install)...
test:
stage: test
script:
- <TRAITEMENT_TEST>
build:
stage: build
- <TRAITEMENT_BUILD>
release:
stage: release
- <TRAITEMENT_RELEASE>
rules:
- if: $CI_COMMIT_BRANCH == "main" # Cet exemple de rule permet déclenche la pipeline suite à un commit sur la branche MAIN. 
Conclusion
Dans ce tutoriel, nous avons montré l’importance des Runners, ses rôles dans le domaine du devops ainsi que comment comment les créer sur Gitlab en utilisant les exécuteurs Kubernetes.
Vous pourrez approfondir vos connaissances sur les cultures, les outils et les pratiques clés de DevOps, ainsi que sur les tendances actuelles et futures du domaine en visitant notre site KELTIOBLOG .
Écrit par
Rayen Merghad
Rayen est notre DevOps Junior, il aime partager son savoir et pratiquer la callisthénie 🤩
Sujets
