Me

Jean-Phi Baconnais

Jean-Phi Baconnais

5 minutes

Dans cet article, je vais vous montrer comment profiter de la puissance de Quarkus et de GitLab CI pour déployer facilement une API Rest sur un cluster Google Kubernetes Engine.

Quarkus

🚀 Quarkus

Si vous ne connaissez pas Quarkus, voici un lien d’un prĂ©cĂ©dent article vous menant Ă  un atelier 🚀 Quarkus.

Création du projet

Tout d’abord, crĂ©ons un projet Quarkus avec l’extension kubernetes :

mvn io.quarkus:quarkus-maven-plugin:1.5.2.Final:create \
    -DprojectGroupId=fr.jpbaconnais \
    -DprojectArtifactId=deployquarkusongkewithgitlab \
    -DclassName="fr.jpbaconnais.HelloWorldFromQuarkus" \
    -Dextensions="kubernetes, container-image-docker"

Lors du dĂ©ploiement de l’application via un mvn compile quarkus:dev la ressource REST suivante http://localhost:8080/hello renvoie une rĂ©ponse avec un code retour 200.

Nous allons faire quelques modifications pour que la suite se passe correctement.

Tout d’abord, supprimons le fichier .dockerignore. Modifions ensuite le fichier src/main/docker/Dockerfile.jvm pour y ajouter une Ă©tape de build maven qui sera la premiĂšre Ă©tape Ă  exĂ©cuter dans le dockerfile :

FROM maven:3.6.3 as builders
RUN mkdir /build
RUN mkdir /build/src
RUN chmod 777 -R /build/
COPY src /build/src/
COPY pom.xml /build/
WORKDIR /build
RUN mvn clean package

Modifions ensuite les deux lignes suivantes pour récupérer les jars générés dans ce nouveau stage docker :

COPY target/lib/* /deployments/lib/
COPY target/*-runner.jar /deployments/app.jar

par

COPY **--from=builders** /build/target/lib/* /deployments/lib/
COPY **--from=builders** /build/target/*-runner.jar /deployments/app.jar

La partie kubernetes

Nous allons modifier le fichier application.properties afin d’y ajouter des modifications sur le nom de l’image utilisĂ©es dans les pods :

quarkus.container-image.registry=registry.gitlab.com <ou votre url d'instance GitLab si vous ĂȘtes en auto hĂ©bergĂ©>
quarkus.container-image.group=<votre identifiant gitlab> 
quarkus.container-image.name=<le nom de votre projet gitlab>
quarkus.container-image.tag=dev

De base, Quarkus renseigne des valeurs par dĂ©faut pour ces variables mais avec l’intĂ©gration via GitLabCI, je choisis de les modifier, vous verrez cela par la suite de cet article 😜.

Quarkus va nous mettre Ă  disposition, grĂące Ă  l’extension kubernetes, deux fichiers lors de l’exĂ©cution d’un mvn clean package en plus des jars de l’application :

  • kubernetes.json
  • kubernetes.yaml

En local, si vous avez une version de docker-desktop ou bien minikube (ou autre), vous pourrez tout simplement déployer votre application via un kubectl apply -f target/kubernetes/kubernetes.yml.

kubectl get pods

NAME                                          READY   STATUS    RESTARTS   AGE
deployquarkusgkewithgitlab-7cc79f7f7d-24jrj   1/1     Running   25         6h9m
deployquarkusgkewithgitlab-7cc79f7f7d-9hzqn   1/1     Running   24         6h9m
deployquarkusgkewithgitlab-7cc79f7f7d-dl659   1/1     Running   24         6h9m
kubectl get deploy

NAME                         READY   UP-TO-DATE   AVAILABLE   AGE
deployquarkusgkewithgitlab   3/3     3            3           6h28m
kubectl get svc

NAME                         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
deployquarkusgkewithgitlab   ClusterIP   10.104.20.238   <none>        9999/TCP   6h28m
kubernetes                   ClusterIP   10.96.0.1       <none>        443/TCP    66d

Et l’exĂ©cution d’une commande curl sur notre ressource permet de voir un joli Hello world from quarkus.

Exec kube


🐬 Google Kubernetes Engine

Pour la partie GKE, je vais vous Ă©pargner l’Ă©tape de crĂ©ation de compte GKE.

Pour créer votre cluster kubernetes, vous avez deux options :

  • le crĂ©er via l’interface de GKE
  • le cluster par l’interface GitLab

Pour cet exemple je vais partir sur la seconde option et utiliser pleinement l’intĂ©gration kubernetes dans GitLabCI pour crĂ©er un cluster GKE. Pour commencer, rendez-vous sur le lien “Kubernetes” dans le menu vertical :

Create Cluster

Sélectionnons la création de cluster sur GKE :

Create Cluster GKE

Renseignons le nom du cluster souhaité :

Put Cluster Name

Et voila ! đŸ€˜

Create Cluster

Sur l’interface graphique de GKE, notre cluster est Ă©galement visible :

Create Cluster


🩊 GitLab

La configuration d’un pipeline GitLabCI se fait via la crĂ©ation d’un fichier .gitlab-ci.yml. Nouveau coup de “pub” 😎, j’avais crĂ©Ă© cet article pour bien 🩊 dĂ©buter avec GitLabCI.

Nous allons donc créer un fichier .gitlab-ci.yml à la racine du projet. Dans ce fichier nous allons vouloir que notre script effectue :

  • une exĂ©cution des tests de notre application
  • une construction de notre image docker via la librairie Kaniko
  • dĂ©ployer notre application sur Google Kubernetes Engine

Le CI/CD avec le fichier .gitlab-ci.yml

Pour effectuer nos 3 jobs, nous allons créer 3 stages :

stages:
  - test
  - build_and_push
  - deploy_gke

Pour le premier job, il suffit d’effectuer un mvn clean verify Ă  partir d’une image maven 3.6.3 :

đŸ©ș execute test :
    stage: test
    image: maven:3.6.3
    script:
      - mvn clean verify  -f deployquarkusongkewithgitlab/pom.xml
    artifacts:
        paths: 
            - deployquarkusongkewithgitlab/target/kubernetes

Nous fixons un artifact sur le rĂ©pertoire target/kubernetes afin de limiter le nombre de fichiers disponibles aprĂšs l’exĂ©cution du job mais aussi pour permettre aux autres jobs de pouvoir utiliser ces fichiers.

Pour la partie build et push, la librairie Kaniko va nous faciliter la tĂąche :

🐳 build push image docker:
  stage: build_and_push
  image:
    name: gcr.io/kaniko-project/executor:debug-v0.19.0
    entrypoint: [""]
  script:
    - echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json
    - /kaniko/executor --context $CI_PROJECT_DIR/deployquarkusongkewithgitlab --dockerfile $CI_PROJECT_DIR/deployquarkusongkewithgitlab/src/main/docker/Dockerfile.jvm --destination deployquarkusgkewithgitlab:dev

Il suffit de renseigner le chemin du Dockerfile, une destination et Kaniko va nous builder l’image et la pusher dans le repository souhaitĂ©. Dans mon utilisation, je vais utiliser le registry de GitLab. Vous comprenez mieux pourquoi j’utilise le paramĂ©trage Quarkus quarkus.container-image 😎.

Pour la derniÚre étape, on va tout simplement prendre une image cloud-sdk de Google sur laquelle on va pouvoir appliquer notre fichier kubernetes.yaml généré par Quarkus.

🐋 deploy on gke:
  stage: deploy_gke
  image: google/cloud-sdk
  script:
    - kubectl apply -f deployquarkusongkewithgitlab/target/kubernetes/kubernetes.yml
  environment: gke

Le mot clĂ© environment est important et est obligatoire pour avoir une intĂ©gration correcte. Cela vous permettra Ă©galement d’avoir une visu de votre environnement dans le menu environnement :

Environment

Dans le pipeline nous pouvons voir que le déploiement a bien été effectué :

Deploy success

Notre infrastructure kubernetes est bien en place sous GKE :

GKE

Nos pods sont bien disponibles :

Pods GKE

Et l’exĂ©cution d’un curl dans un pod nous renvoie bien notre Hello from Quarkus ! đŸ€˜

curl pod


Supervision

Et en bonus, pour superviser notre infrastructure GKE, certaines métriques sont directement disponibles sous GitLab :

Supervision


Si vous avez des remarques sur cet article, n’hĂ©sitez pas Ă  me les faire parvenir 😃


Posts récents

Voir plus

Jean-Phi Baconnais

Consultant développeur @ Zenika Nantes
🩊 #GitLabHeroes