Remarques :

Déployer vers OCI Container Engine for Kubernetes à partir de l'intégration et du déploiement continus GitLab

Introduction

Dans le paysage en évolution rapide du développement DevOps et cloud natif, la nécessité d'une intégration rationalisée entre les systèmes de contrôle de version et les plates-formes d'orchestration de conteneurs peut être cruciale. Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) offre une solution robuste et évolutive pour la gestion d'applications en conteneur. Cependant, certaines équipes peuvent avoir des préférences et des exigences spécifiques qui les amènent à rechercher des alternatives aux services DevOps natifs d'Oracle Cloud Infrastructure (OCI).

GitLab est une plate-forme de contrôle de version complète et polyvalente, d'intégration continue et de déploiement continu qui répond non seulement à ces préférences, mais fournit également une alternative convaincante aux services OCI DevOps. Dans ce tutoriel, nous vous guiderons tout au long du processus de connexion transparente de GitLab à Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE). L'intégration présentée dans ce tutoriel s'aligne non seulement pour utiliser une solution GitLab existante que vous pourriez avoir en place, mais donne également à l'équipe une solution unifiée pour le contrôle des versions, l'intégration continue et l'orchestration Kubernetes.

Dans les sections suivantes, ce tutoriel présente deux approches distinctes visant à effectuer cette intégration.

Objectifs

Prérequis

Approche 1 : déploiement vers OKE à partir de l'intégration continue et du déploiement continu GitLab à l'aide d'un jeton généré de courte durée

Tâche 1 : préparer l'instance de calcul OCI

Vous aurez besoin d'une instance OCI Compute pour l'exécuteur GitLab, par exemple une machine virtuelle.

Instance OCI Compute

  1. Installez kubectl sur la machine virtuelle. Pour plus d'informations, reportez-vous à Installation et configuration de kubectl sous Linux.

  2. Installez l'interface de ligne de commande OCI et créez le fichier de configuration pour l'authentification à la location OCI (ou vous serez invité à le créer lors de l'exécution des étapes d'accès au cluster). Pour plus d'informations, reportez-vous à Installation de l'interface de ligne de commande OCI et à Fichier de configuration du kit SDK et de l'interface de ligne de commande.

  3. Configurer l'accès au cluster OKE. Accédez à Accès au cluster et cliquez sur les instructions d'accès local à partir de la console OCI.

    Cluster d'accès OCI OKE

  4. Installez GitLab Runner sur la machine virtuelle. Exécutez les commandes suivantes en tant qu'utilisateur root.

    sudo curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.rpm.sh | sudo bash
sudo yum install -y gitlab-runner

    Vérifiez que GitLab Runner fonctionne.

    gitlab-runner list

Tâche 2 : configurer le programme d'exécution et le projet GitLab

  1. Connectez-vous à GitLab, accédez à Projets et créez un projet ou utilisez un projet existant.

    GitLab Projet

  2. Créez un programme d'exécution ou utilisez-en un existant. Pour créer un programme d'exécution, accédez à Paramètres, CI/CD, Exécuteurs et Développer. Cliquez sur Nouveau programme d'exécution de projet et sélectionnez Plate-forme (par exemple : Linux), ajoutez une balise que nous utiliserons plus tard dans le fichier .gitlab-ci.yaml lors de la configuration du pipeline de déploiement, puis cliquez sur Créer un programme d'exécution.

    GitLab Runner

  3. Enregistrez le programme d'exécution avec la machine virtuelle.

    Remarque : notez le jeton d'authentification du processus d'exécution au cas où vous en auriez besoin ultérieurement.

    Inscrire le coureur

    • Exécutez la commande gitlab-runner register et entrez les informations suivantes.

      • URL d'instance GitLab : acceptez la valeur par défaut https://gitlab.com.
      • Nom du programme d'exécution : valide localement dans le fichier config.toml. Par exemple : gitlab-oke-runner.
      • Entrer un exécuteur : shell, avec cette valeur, vous choisissez que les instructions d'intégration continue et de déploiement continu soient exécutées sur l'ordinateur local sur lequel kubectl et l'interface de ligne de commande OCI sont installés.

      Inscrire le coureur

    • Vous pouvez consulter la configuration du programme d'exécution dans le fichier $HOME/.gitlab-runner/config.toml.

Tâche 3 : configurer le pipeline d'intégration continue et de déploiement continu

  1. Clonez le projet GitLab sur votre ordinateur local.

  2. Créez un fichier nommé .gitlab-ci.yaml dans le répertoire du projet, contenant les instructions de build et de déploiement. Dans la section de déploiement, veillez à inclure la balise de programme d'exécution que vous avez définie lors de la création du programme d'exécution avant.

    $ cat ~/demo-oke/.gitlab-ci.yml
stages:
  - build
  - deploy

build_job:
  stage: build
  script:
    - echo "Building the ServiceAccount project..."

deploy_job:
  stage: deploy
  script:
    - echo "Deploying an nginx pod to the OKE cluster"
    - kubectl run nginx --image=nginx
  tags:
    - shell-executor

  3. Transmettez les modifications à votre projet GitLab et accédez à Création et à Travaux pour vérifier que les pipelines de build et de déploiement sont déclenchés et exécutés avec succès.

    Pipelines CICD

    Déployer le travail

    Le pipeline a déployé un pod nginx dans le cluster OKE.

    Remarques : notez la balise et la clé. Nous choisirons l'exécuteur shell qui utilisera les ressources de machine locales. Sinon, si vous choisissez Docker par exemple, vous devez fournir dans vos instructions une image qui installe kubectl (et l'interface de ligne de commande OCI pour l'approche 1) dans le conteneur.

    $ kubectl get pods
NAME    READY   STATUS    RESTARTS   AGE
nginx   1/1     Running   0          47h

Approche 2 : déploiement vers OKE à partir de l'intégration continue et du déploiement continu GitLab à l'aide d'un compte de service Kubernetes

Répétez les tâches 1, 2 et 3 de l'approche 1 pour configurer la machine virtuelle locale (installation de kubectl, interface de ligne de commande OCI, programme d'exécution GitLab), inscrire le programme d'exécution, créer le fichier de pipeline .gitlab-ci.yaml.

Tâche 1 : créer un compte de service Kubernetes et ajouter son jeton

Lorsque vous utilisez un compte de service Kubernetes pour effectuer un déploiement vers OKE à partir de GitLab, le processus implique l'authentification de GitLab avec le cluster Kubernetes à l'aide des informations d'identification de compte de service.

Etapes suivantes

A l'aide de ces tâches, vous pouvez utiliser votre pipeline d'intégration continue et de déploiement continu GitLab pour effectuer un déploiement vers OKE. Ces tâches peuvent servir de référence pour d'autres outils d'intégration continue et de déploiement continu. L'intégration facilite l'intégration et la livraison continues, ce qui permet une itération et un déploiement rapides des applications vers OKE.

Dans ce tutoriel, les instructions utilisent un exécuteur shell pour tester et gérer des scénarios simples. Vous pouvez également opter pour un autre exécuteur, par exemple un exécuteur Docker. Dans ce cas, le pipeline est exécuté dans un conteneur Docker plutôt que sur l'ordinateur local. L'exécution avec un exécuteur Docker nécessite que vous indiquiez une image Docker qui inclut les utilitaires requis. Par conséquent, il peut être essentiel de créer une image personnalisée, en intégrant des outils tels que kubectl et l'interface de ligne de commande OCI pour répondre à des exigences de pipeline spécifiques.

Accusés de réception

Ressources de formation supplémentaires

Parcourez d'autres ateliers sur docs.oracle.com/learn ou accédez à davantage de contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, rendez-vous sur education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.