Tâche 2 : Provisionner Jenkins

Vous allez créer un cluster Kubernetes et autoriser Jenkins à accéder aux services Google Cloud et à Google Artifact Registry.

Créer un cluster Kubernetes

1. Exécutez maintenant la commande suivante pour provisionner un cluster Kubernetes :

gcloud container clusters create jenkins-cd \ --num-nodes 2 \ --machine-type e2-standard-2 \ --scopes "https://www.googleapis.com/auth/source.read_write,cloud-platform"

Cette étape peut prendre plusieurs minutes. Les champs d'application supplémentaires permettent à Jenkins d'accéder aux services Google Cloud et à Google Artifact Registry.

Créer un cluster Kubernetes

1. À présent, exécutez la commande suivante pour provisionner un cluster Kubernetes :

gcloud container clusters create jenkins-cd \ --num-nodes 2 \ --machine-type e2-standard-2 \ --scopes "https://www.googleapis.com/auth/source.read_write,cloud-platform"

Cette étape peut prendre plusieurs minutes. Les niveaux d'accès supplémentaires autorisent l'accès de Jenkins aux services Google Cloud et à Google Artifact Registry.

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à créer le cluster Kubernetes, vous verrez une note d'évaluation s'afficher.

Créer un cluster Kubernetes (zone : )

2. Avant de poursuivre, vérifiez que votre cluster est en cours d'exécution à l'aide de la commande suivante :

gcloud container clusters list

Obtenir les identifiants du cluster

1. Récupérez les identifiants de votre cluster :

gcloud container clusters get-credentials jenkins-cd

2. Ces identifiants permettent à Kubernetes Engine d'accéder au cluster que vous venez de provisionner. Vérifiez que vous pouvez vous y connecter en exécutant la commande suivante :

kubectl cluster-info

Tâche 3 : Configurer Helm

Helm est un gestionnaire de paquets qui facilite la configuration et le déploiement des applications Kubernetes. Après avoir installé Jenkins, vous pourrez configurer votre pipeline CI/CD.

Dans cette tâche, vous allez utiliser Helm pour installer Jenkins à partir du dépôt des charts.

1. Ajoutez le dépôt de charts de la version stable de Helm :

helm repo add jenkins https://charts.jenkins.io

2. Vérifiez que le dépôt est à jour :

helm repo update

Tâche 4 : Installer et configurer Jenkins

Lors de l'installation de Jenkins, vous pouvez utiliser un fichier values comme modèle pour fournir les valeurs de configuration nécessaires.

Vous allez utiliser un fichier values personnalisé pour configurer automatiquement votre cloud Kubernetes et ajouter les plug-ins nécessaires suivants :

• Kubernetes:latest
• Workflow-multibranch:latest
• Git:latest
• Configuration-as-code:latest
• Google-oauth-plugin:latest
• Google-source-plugin:latest
• Google-storage-plugin:latest

Cela permet à Jenkins de se connecter à votre cluster et à votre projet Google Cloud.

1. Via la CLI Helm, déployez le chart avec vos paramètres de configuration :

helm install cd jenkins/jenkins -f jenkins/values.yaml --wait

Cette commande peut prendre quelques minutes pour s'exécuter.

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à configurer un chart Jenkins, vous verrez une note d'évaluation s'afficher.

Configurer et installer Jenkins

2. Une fois l'exécution de la commande terminée, vérifiez que le pod Jenkins passe à l'état Running (En cours d'exécution) et que l'état du conteneur est "READY" (Prêt) :

kubectl get pods

Exemple de résultat :

NAME READY STATUS RESTARTS AGE cd-jenkins-7c786475dd-vbhg4 2/2 Running 0 1m

3. Configurez le compte de service Jenkins pour pouvoir déployer dans le cluster :

kubectl create clusterrolebinding jenkins-deploy --clusterrole=cluster-admin --serviceaccount=default:cd-jenkins

Vous devez obtenir le résultat suivant :

clusterrolebinding.rbac.authorization.k8s.io/jenkins-deploy created

4. Exécutez la commande suivante à partir de Cloud Shell pour configurer le transfert de port vers l'interface utilisateur de Jenkins :

export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/component=jenkins-master" -l "app.kubernetes.io/instance=cd" -o jsonpath="{.items[0].metadata.name}") kubectl port-forward $POD_NAME 8080:8080 >> /dev/null &

5. À présent, vérifiez que le service Jenkins a bien été créé :

kubectl get svc

Exemple de résultat :

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE cd-jenkins 10.35.249.67 8080/TCP 3h cd-jenkins-agent 10.35.248.1 50000/TCP 3h kubernetes 10.35.240.1 443/TCP 9h

Vous utilisez le plug-in Kubernetes afin que les nœuds de compilation se lancent automatiquement si nécessaire lorsque le maître Jenkins les demande. Une fois leur travail terminé, ces nœuds sont arrêtés automatiquement et leurs ressources sont restituées au pool de ressources du cluster.

Notez que ce service expose les ports 8080 et 50000 à tous les pods correspondant au sélecteur (selector). Cela expose les ports d'enregistrement de l'interface utilisateur Web et du compilateur/de l'agent Jenkins dans le cluster Kubernetes. De plus, le service jenkins-ui est exposé via une adresse IP de cluster, et donc inaccessible depuis l'extérieur du cluster.

Tâche 5 : Se connecter à Jenkins

Récupérez le mot de passe administrateur et connectez-vous à l'interface de Jenkins.

1. Le chart Jenkins crée automatiquement un mot de passe administrateur pour vous. Pour le récupérer, exécutez la commande suivante :

printf $(kubectl get secret cd-jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo

2. Pour accéder à l'interface utilisateur de Jenkins, cliquez sur Aperçu sur le Web () > Prévisualiser sur le port 8080 dans la barre d'actions de Cloud Shell :

3. Si vous y êtes invité, connectez-vous avec le nom d'utilisateur admin et le mot de passe généré automatiquement.

Jenkins est maintenant configuré dans votre cluster Kubernetes. Il gérera les pipelines CI/CD automatisés que vous allez créer dans les sections qui suivent.

Tâche 6 : Analyser l'application

Dans cette tâche, vous allez déployer l'exemple d'application gceme dans votre pipeline de déploiement continu. Cette application, codée en langage Go, se situe dans le répertoire sample-app du dépôt. Lorsque vous exécutez le binaire gceme sur une instance Compute Engine, l'application affiche les métadonnées de cette dernière dans une fiche info.

L'application s'apparente à un microservice proposant deux modes de fonctionnement.

• En mode backend : gceme écoute le port 8080 et renvoie les métadonnées de l'instance Compute Engine au format JSON.
• En mode interface : gceme interroge le service backend gceme et affiche dans l'interface utilisateur le fichier JSON ainsi obtenu.

Tâche 7 : Déployer l'application

Vous allez déployer l'application dans deux environnements différents :

• Production : site en ligne auquel vos utilisateurs accèdent.
• Canary : site de moindre capacité recevant seulement une partie du trafic utilisateur. Cet environnement vous permet de valider votre logiciel avec une partie du trafic en ligne, avant de le publier pour l'ensemble des utilisateurs.

1. Dans Google Cloud Shell, accédez au répertoire de l'exemple d'application :

cd sample-app

2. Créez l'espace de noms Kubernetes afin d'isoler logiquement le déploiement :

kubectl create ns production

3. Créez les déploiements de production et Canary, ainsi que les services, à l'aide de commandes kubectl apply :

kubectl apply -f k8s/production -n production kubectl apply -f k8s/canary -n production kubectl apply -f k8s/services -n production

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à créer les déploiements, vous verrez une note d'évaluation s'afficher.

Créer des déploiements de production et Canary

Par défaut, seule une instance répliquée de l'interface est déployée. Avec la commande kubectl scale, faites en sorte qu'au moins quatre instances répliquées s'exécutent en permanence.

4. Pour augmenter le nombre d'interfaces dans l'environnement de production, exécutez la commande suivante :

kubectl scale deployment gceme-frontend-production -n production --replicas 4

5. À présent, vérifiez que cinq pods s'exécutent pour l'interface, quatre pour le trafic de production et un pour la version Canary (les modifications apportées à la version Canary ne toucheront qu'un utilisateur sur cinq, soit 20 % des utilisateurs) :

kubectl get pods -n production -l app=gceme -l role=frontend

6. Vérifiez aussi que vous avez deux pods pour le backend, un pour l'environnement de production et un pour l'environnement Canary :

kubectl get pods -n production -l app=gceme -l role=backend

7. Récupérez l'adresse IP externe des services de production :

kubectl get service gceme-frontend -n production Remarque : Il peut s'écouler plusieurs minutes avant que l'adresse IP externe de l'équilibreur de charge apparaisse.

Exemple de résultat :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE gceme-frontend LoadBalancer 10.79.241.131 104.196.110.46 80/TCP 5h

Collez l'adresse IP externe dans un navigateur pour afficher la fiche info, laquelle se présente comme suit :

8. À présent, consignez l'adresse IP de l'équilibreur de charge du service d'interface dans une variable d'environnement afin de pouvoir l'utiliser ultérieurement :

export FRONTEND_SERVICE_IP=$(kubectl get -o jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend)

9. Afin de vérifier que les deux services fonctionnent, ouvrez l'adresse IP externe de l'interface dans votre navigateur.

10. Vérifiez la version du service à l'aide de la commande suivante (qui devrait renvoyer 1.0.0) :

curl http://$FRONTEND_SERVICE_IP/version

Vous venez de déployer l'exemple d'application. Vous allez maintenant configurer un pipeline pour déployer vos modifications de manière continue et fiable.

Tâche 8 : Créer le pipeline Jenkins

Dans cette tâche, vous allez configurer un dépôt Git sur votre serveur Git dédié et créer le pipeline Jenkins :

• Transférer le code source de l'application exemple vers le serveur Git
• Ajouter vos identifiants de compte de service à Jenkins
• Configurer Jenkins Cloud pour Kubernetes
• Créer la tâche de pipeline multibranche Jenkins

Transférer le code source de l'application exemple vers le serveur Git

1. Dans Cloud Shell, récupérez l'adresse IP externe de votre serveur Git :

export GIT_SERVER_IP=$(gcloud compute instances describe git-server --zone={{{project_0.default_zone}}} --format='get(networkInterfaces[0].accessConfigs[0].natIP)') echo "Git Server IP: ${GIT_SERVER_IP}"

2. Initialisez le répertoire sample-app en tant que dépôt Git :

cd ~/continuous-deployment-on-kubernetes/sample-app git init git config --global user.email "student@qwiklabs.net" git config --global user.name "Student" git branch -m master

3. Ajoutez le dépôt distant pointant vers votre serveur Git auto-hébergé :

git remote add origin http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/sample-app.git

4. Ajoutez, validez et transférez les fichiers vers la branche master :

git add . git commit -m "Initial commit" git push -u origin master

Ajouter les identifiants de votre compte de service

Configurez vos identifiants pour permettre à Jenkins d'accéder au cluster et de déployer des ressources.

1. Dans l'interface utilisateur de Jenkins, cliquez sur Manage Jenkins dans le panneau de gauche, puis sur Credentials (sous Security).

2. Sous Stores scoped to Jenkins, cliquez sur System.

3. Cliquez sur Global credentials (unrestricted).

4. Cliquez sur Add Credentials.

5. Pour Kind, sélectionnez Google Service Account from metadata et cliquez sur Next.

6. Dans le champ ID, saisissez l'identifiant de votre projet () et cliquez sur Create.

Remarque : L'ID de votre projet est disponible dans le panneau DÉTAILS DE CONNEXION de l'atelier.

Les identifiants globaux ont été ajoutés.

Configurer Jenkins Cloud pour Kubernetes

1. Dans l'interface utilisateur de Jenkins, sélectionnez Manage Jenkins > Clouds (ou System > Clouds).
2. Cliquez sur New cloud.
3. Dans le champ Cloud name, saisissez kubernetes, sélectionnez Kubernetes pour Type, puis cliquez sur Create.
4. Dans le champ Jenkins URL, saisissez la valeur http://cd-jenkins:8080.
5. Dans le champ Jenkins tunnel, saisissez la valeur cd-jenkins-agent:50000.
6. Cliquez sur Save.

Créer la tâche Jenkins

Accédez à votre interface utilisateur Jenkins et suivez les étapes ci-dessous pour configurer une tâche de pipeline multibranche :

1. Cliquez sur Jenkins > New Item dans le panneau de gauche.

2. Saisissez le nom sample-app, sélectionnez l'option Multibranch Pipeline et cliquez sur OK.

3. Sur la page suivante, dans la section Branch Sources, sélectionnez Git dans le menu déroulant Add source.

4. Dans le champ Project Repository, collez l'URL de clonage de votre dépôt :

http://{{{project_0.startup_script.git_server_ip}}}:3000/giteaadmin/sample-app.git Remarque : Si la variable n'est pas renseignée, vous pouvez saisir http://[GIT_SERVER_IP]:3000/giteaadmin/sample-app.git en remplaçant [GIT_SERVER_IP] par l'adresse IP de votre serveur Git.

5. Sous Credentials, laissez la valeur - none -.

6. Dans la section Scan Multibranch Pipeline Triggers, cochez l'option Periodically if not otherwise run et définissez Interval sur 1 minute.

7. Laissez toutes les autres options sur leurs valeurs par défaut, puis cliquez sur Save.

Une fois ces étapes terminées, une tâche nommée Branch indexing s'exécute. Cette méta-tâche identifie les branches de votre dépôt et s'assure qu'aucun changement n'a eu lieu dans les branches existantes. Si vous cliquez sur sample-app dans le fil d'Ariane, la tâche master devrait apparaître.

Remarque : La première exécution de la tâche master peut échouer jusqu'à ce que vous apportiez des modifications au code à l'étape suivante.

Vous avez créé un pipeline Jenkins avec succès. Vous allez maintenant créer l'environnement de développement pour l'intégration continue.

Tâche 9 : Créer l'environnement de développement

Les branches de développement représentent un ensemble d'environnements dans lesquels vos développeurs testent les modifications qu'ils apportent au code avant qu'elles ne soient intégrées sur le site en ligne. Ces environnements sont des versions réduites de votre application, mais vous devez les déployer avec les mêmes mécanismes que l'environnement en ligne.

Créer une branche de développement

Pour créer un environnement de développement à partir d'une branche de fonctionnalité, vous pouvez transférer la branche en question vers le serveur Git et laisser Jenkins déployer votre environnement.

Remarque : Si des erreurs s'affichent dans Cloud Shell, appuyez sur CTRL+C, puis exécutez la commande ci-dessous.

• Créez une branche de développement et transférez-la sur le serveur Git :

git checkout -b new-feature

Modifier la définition du pipeline

Le code du fichier Jenkinsfile qui définit ce pipeline utilise la syntaxe Groovy de pipeline Jenkins. L'ensemble d'un pipeline de compilation peut ainsi être défini dans un fichier Jenkinsfile unique accompagnant votre code source. Les pipelines offrent des fonctionnalités extrêmement utiles telles que le chargement en parallèle, et ils requièrent l'approbation manuelle de l'utilisateur.

Pour que le pipeline fonctionne comme prévu, vous devez indiquer l'ID de votre projet dans le fichier Jenkinsfile.

1. Ouvrez le fichier Jenkinsfile dans l'éditeur de votre terminal, par exemple vi :

vi Jenkinsfile

2. Lancez l'éditeur :

i

3. Insérez votre PROJECT_ID à la place de la valeur REPLACE_WITH_YOUR_PROJECT_ID. La valeur PROJECT_ID correspond à l'ID de votre projet, qui se trouve dans la section DÉTAILS DE CONNEXION de l'atelier. Vous pouvez également exécuter gcloud config get-value project pour obtenir cette valeur.

4. Définissez la valeur CLUSTER_ZONE sur . Pour obtenir cette valeur, exécutez la commande gcloud config get compute/zone.

PROJECT = "REPLACE_WITH_YOUR_PROJECT_ID" APP_NAME = "gceme" FE_SVC_NAME = "${APP_NAME}-frontend" CLUSTER = "jenkins-cd" CLUSTER_ZONE = "{{{project_0.default_zone}}}" IMAGE_TAG = "gcr.io/${PROJECT}/${APP_NAME}:${env.BRANCH_NAME}.${env.BUILD_NUMBER}" JENKINS_CRED = "${PROJECT}"

5. Pour enregistrer le fichier Jenkinsfile, appuyez sur la touche ÉCHAP, puis (si vous utilisez vi) saisissez :

:wq

Modifier le site

Pour illustrer un changement dans l'application, vous allez faire passer la couleur des fiches gceme du bleu à l'orange.

1. Ouvrez html.go :

vi html.go

2. Lancez l'éditeur :

i

3. Remplacez les deux occurrences de <div class="card blue"> par ce qui suit :

<div class="card orange">

4. Pour enregistrer le fichier html.go, appuyez sur ÉCHAP, puis saisissez :

:wq

5. Ouvrez le fichier main.go :

vi main.go

6. Lancez l'éditeur :

i

7. La version est définie sur cette ligne :

const version string = "1.0.0"

Modifiez-la comme suit :

const version string = "2.0.0"

8. Enregistrez à nouveau le fichier main.go (appuyez sur ÉCHAP, puis saisissez ceci) :

:wq

Tâche 10 : Démarrer le déploiement

Dans cette tâche, vous allez déployer votre environnement de développement.

1. Validez et transférez vos modifications :

git add Jenkinsfile html.go main.go git commit -m "Version 2.0.0" git push origin new-feature

Ces opérations déclenchent une compilation de votre environnement de développement.

Une fois la modification transférée dans le dépôt Git, accédez à l'interface utilisateur Jenkins. Celle-ci indique que votre compilation a été lancée pour la branche new-feature. La prise en compte des modifications peut demander jusqu'à une minute.

2. Lorsque la compilation s'exécute, cliquez sur la flèche vers le bas à côté de build (compilation) dans le menu de navigation de gauche, puis sélectionnez Console output (Résultat de la console) :

3. Attendez quelques minutes pour voir apparaître les premiers messages kubectl --namespace=new-feature apply... dans le résultat de la compilation. La branche new-feature est maintenant déployée dans votre cluster.

Remarque : Dans un scénario de développement, vous n'utiliseriez pas d'équilibreur de charge public. Vous pouvez sécuriser votre application avec le proxy kubectl. Ce proxy s'authentifie auprès de l'API Kubernetes et traite les requêtes envoyées de votre machine locale vers le service dans le cluster sans exposer votre service à Internet.

Si vous n'avez rien vu s'afficher dans Build Executor, ne vous inquiétez pas. Il suffit d'accéder à la page d'accueil Jenkins > sample app. Vérifiez que le pipeline new-feature a bien été créé.

4. Une fois ces opérations effectuées, lancez le proxy en arrière-plan :

kubectl proxy &

5. S'il se bloque, appuyez sur CTRL+C pour quitter. Pour vérifier que votre application est accessible, envoyez une requête à localhost et laissez le proxy kubectl la transférer à votre service :

curl \ http://localhost:8001/api/v1/namespaces/new-feature/services/gceme-frontend:80/proxy/version

Vous recevrez en réponse "2.0.0", ce qui correspond à la version en cours d'exécution.

Il se peut que vous receviez une erreur semblable à celle-ci :

{ "kind": "Status", "apiVersion": "v1", "metadata": { }, "status": "Failure", "message": "no endpoints available for service \"gceme-frontend:80\"", "reason": "ServiceUnavailable", "code": 503

6. Cela signifie que votre point de terminaison de l'interface ne s'est pas encore propagé. Patientez un peu et essayez de réexécuter la commande curl. Continuez lorsque vous obtenez le résultat suivant :

2.0.0

Vous venez de configurer l'environnement de développement. Vous allez maintenant exploiter les connaissances acquises durant le module précédent en déployant une version Canary pour tester une nouvelle fonctionnalité.

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à lancer la compilation de la branche new-feature, vous verrez une note d'évaluation s'afficher.

Lancer une compilation de la branche new-feature

Tâche 11 : Déployer une version Canary

Vous avez vérifié que votre application exécute le dernier code dans l'environnement de développement. Vous allez maintenant déployer ce code dans l'environnement Canary.

1. Créez une branche Canary et transférez-la sur le serveur Git :

git checkout -b canary git push origin canary

2. Dans Jenkins, vous devriez voir que le pipeline Canary s'est lancé. Lorsqu'il a complètement démarré, vous pouvez vérifier l'URL du service pour vous assurer que votre nouvelle version dessert une partie du trafic. Environ une requête sur cinq (sans ordre particulier) doit renvoyer la version 2.0.0.

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Si la version 1.0.0 apparaît systématiquement, essayez de réexécuter les commandes ci-dessus. Après avoir vérifié que tout fonctionne, arrêtez les commandes en appuyant sur CTRL+C.

Et voilà ! Vous avez déployé une version Canary. Vous allez maintenant déployer la nouvelle version en production.

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à déployer la version Canary, vous verrez une note d'évaluation s'afficher.

Déployer une version Canary

Tâche 12 : Déployer en production

Maintenant que notre version Canary est publiée et que nous n'avons reçu aucune réclamation de client, nous pouvons déployer tout notre parc de production.

1. Créez une branche Canary et transférez-la sur le serveur Git :

git checkout master git merge canary git push origin master

Dans Jenkins, vous devriez voir que le pipeline maître a démarré.

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à lancer le pipeline maître, vous verrez une note d'évaluation s'afficher.

Déployer en production

2. Une fois l'opération terminée (ce qui peut prendre quelques minutes), vous pouvez vérifier l'URL du service pour vous assurer que c'est bien la nouvelle version 2.0.0 qui dessert la totalité du trafic.

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Comme précédemment, si vous voyez la version 1.0.0 apparaître, essayez de réexécuter les commandes ci-dessus. Pour arrêter ces commandes, appuyez sur CTRL+C.

Exemple de résultat :

gcpstaging9854_student@qwiklabs-gcp-df93aba9e6ea114a:~/continuous-deployment-on-kubernetes/sample-app$ while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 ^C

Vous pouvez aussi accéder au site sur lequel l'application gceme présente les fiches info. La couleur de la fiche est passée du bleu à l'orange.

4. Voici à nouveau la commande permettant d'obtenir l'adresse IP externe. Copiez l'adresse IP externe dans un nouvel onglet pour afficher la fiche info :

kubectl get service gceme-frontend -n production

Exemple de résultat :

Tâche 13 : Tester vos connaissances

Voici quelques questions à choix multiples visant à consolider vos acquis sur les concepts abordés lors de cet atelier. Répondez-y du mieux que vous le pouvez.

Vous avez terminé.

Excellent travail ! Vous venez de déployer votre application en production.

Félicitations !

Notre atelier pratique sur le déploiement et l'utilisation de Jenkins dans Kubernetes Engine en vue de créer un pipeline de livraison continue/déploiement continu se termine ici. Vous avez eu l'occasion de déployer un outil DevOps important dans Kubernetes Engine et de le configurer pour l'utiliser en production. Vous avez travaillé avec l'outil de ligne de commande kubectl et avec des configurations de déploiement dans des fichiers YAML, et vous en avez appris un peu plus sur la création de pipelines Jenkins pour un processus de développement/déploiement. Grâce à cette expérience pratique, vous devriez être en mesure d'exploiter ces outils dans vos propres activités DevOps.

Étapes suivantes et informations supplémentaires

• Pour plus d'informations, consultez cet article sur la solution Jenkins dans Kubernetes Engine.
• Découvrez comment activer la livraison continue dans Kubernetes Engine avec Jenkins.
• Vous trouverez davantage d'informations sur les solutions et guides DevOps dans la documentation de Google Cloud.
• Échangez avec la communauté Jenkins !

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 20 mai 2026

Dernier test de l'atelier : 26 février 2026

Copyright 2026 Google LLC. Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.