5.3. Construction de pipelines

Procédure

1. Créer le maître Jenkins:

     $ oc project <project_name>

   Copy to Clipboard Toggle word wrap

   Choisissez le projet que vous souhaitez utiliser ou créez un nouveau projet avec oc new-project <project_name>.

     $ oc new-app jenkins-ephemeral 

   1

   Copy to Clipboard Toggle word wrap

   À la place, si vous souhaitez utiliser un stockage persistant, utilisez des jenkins-persistents.

2. Créez un fichier nommé nodejs-sample-pipeline.yaml avec le contenu suivant:

   Note

   Cela crée un objet BuildConfig qui utilise la stratégie de pipeline Jenkins pour construire, déployer et mettre à l’échelle l’application d’exemple Node.js/MongoDB.

   kind: "BuildConfig"
   apiVersion: "v1"
   metadata:
     name: "nodejs-sample-pipeline"
   spec:
     strategy:
       jenkinsPipelineStrategy:
         jenkinsfile: <pipeline content from below>
       type: JenkinsPipeline

   Copy to Clipboard Toggle word wrap

3. Après avoir créé un objet BuildConfig avec un jenkinsPipelineStrategy, dites au pipeline quoi faire en utilisant un jenkinsfile en ligne:

   Note

   Cet exemple ne met pas en place un référentiel Git pour l’application.

   Le contenu jenkinsfile suivant est écrit dans Groovy en utilisant le service Red Hat OpenShift sur AWS DSL. Dans cet exemple, incluez du contenu en ligne dans l’objet BuildConfig en utilisant le style YAML Literal, bien que l’inclusion d’un fichier jenkins dans votre référentiel source soit la méthode préférée.

   def templatePath = 'https://raw.githubusercontent.com/openshift/nodejs-ex/master/openshift/templates/nodejs-mongodb.json' 

   1

   
   def templateName = 'nodejs-mongodb-example' 

   2

   
   pipeline {
     agent {
       node {
         label 'nodejs' 

   3

   
       }
     }
     options {
       timeout(time: 20, unit: 'MINUTES') 

   4

   
     }
     stages {
       stage('preamble') {
           steps {
               script {
                   openshift.withCluster() {
                       openshift.withProject() {
                           echo "Using project: ${openshift.project()}"
                       }
                   }
               }
           }
       }
       stage('cleanup') {
         steps {
           script {
               openshift.withCluster() {
                   openshift.withProject() {
                     openshift.selector("all", [ template : templateName ]).delete() 

   5

   
                     if (openshift.selector("secrets", templateName).exists()) { 

   6

   
                       openshift.selector("secrets", templateName).delete()
                     }
                   }
               }
           }
         }
       }
       stage('create') {
         steps {
           script {
               openshift.withCluster() {
                   openshift.withProject() {
                     openshift.newApp(templatePath) 

   7

   
                   }
               }
           }
         }
       }
       stage('build') {
         steps {
           script {
               openshift.withCluster() {
                   openshift.withProject() {
                     def builds = openshift.selector("bc", templateName).related('builds')
                     timeout(5) { 

   8

   
                       builds.untilEach(1) {
                         return (it.object().status.phase == "Complete")
                       }
                     }
                   }
               }
           }
         }
       }
       stage('deploy') {
         steps {
           script {
               openshift.withCluster() {
                   openshift.withProject() {
                     def rm = openshift.selector("dc", templateName).rollout()
                     timeout(5) { 

   9

   
                       openshift.selector("dc", templateName).related('pods').untilEach(1) {
                         return (it.object().status.phase == "Running")
                       }
                     }
                   }
               }
           }
         }
       }
       stage('tag') {
         steps {
           script {
               openshift.withCluster() {
                   openshift.withProject() {
                     openshift.tag("${templateName}:latest", "${templateName}-staging:latest") 

   10

   
                   }
               }
           }
         }
       }
     }
   }

   Copy to Clipboard Toggle word wrap

   1

   Chemin du modèle à utiliser.

   1 2

   Le nom du modèle qui sera créé.

   3

   Lancez un pod d’agent node.js sur lequel exécuter cette construction.

   4

   Fixez un délai de 20 minutes pour ce pipeline.

   5

   Effacer tout avec cette étiquette de modèle.

   6

   Effacer tous les secrets avec cette étiquette de modèle.

   7

   Créez une nouvelle application à partir du templatePath.

   8

   Attendez jusqu’à cinq minutes pour que la construction soit terminée.

   9

   Attendez jusqu’à cinq minutes pour que le déploiement se termine.

   10

   Lorsque tout le reste réussit, marquez $ {templateName}:dernière image comme $ {templateName}-staging:lastest. La configuration de construction de pipeline pour l’environnement de mise en scène peut regarder pour $ {templateName}-staging:dernière image à changer, puis la déployer dans l’environnement de mise en scène.

   Note

   L’exemple précédent a été écrit en utilisant le style de pipeline déclaratif, mais l’ancien style de pipeline scripté est également pris en charge.

4. Créez le Pipeline BuildConfig dans votre Red Hat OpenShift Service sur AWS cluster:

   $ oc create -f nodejs-sample-pipeline.yaml

   Copy to Clipboard Toggle word wrap

   1. Dans le cas où vous ne souhaitez pas créer votre propre fichier, vous pouvez utiliser l’échantillon du référentiel Origin en exécutant:

      $ oc create -f https://raw.githubusercontent.com/openshift/origin/master/examples/jenkins/pipeline/nodejs-sample-pipeline.yaml

      Copy to Clipboard Toggle word wrap

5. Démarrez le pipeline:

   $ oc start-build nodejs-sample-pipeline

   Copy to Clipboard Toggle word wrap
   Note

   Alternativement, vous pouvez démarrer votre pipeline avec le service Red Hat OpenShift sur la console Web AWS en naviguant vers la section Builds Pipeline et en cliquant sur Démarrer le pipeline, ou en visitant la console Jenkins, en naviguant vers le pipeline que vous avez créé, et en cliquant sur Construire maintenant.

   Lorsque le pipeline est lancé, vous devriez voir les actions suivantes effectuées dans le cadre de votre projet:

   • L’instance d’emploi est créée sur le serveur Jenkins.
   • La gousse d’agent est lancée, si votre pipeline en a besoin.

   • Le pipeline coule sur la gousse d’agent, ou le capitaine si aucun agent n’est requis.

     • Les ressources précédemment créées avec l’étiquette template=nodejs-mongodb-example seront supprimées.
     • Le modèle nodejs-mongodb-exemple de nodejs-mongodb-exemple créera une nouvelle application et toutes ses ressources associées.

     • La construction sera lancée à l’aide de l’exemple nodejs-mongodb BuildConfig.

       • Le pipeline attendra jusqu’à ce que la construction soit terminée pour déclencher la prochaine étape.

     • Le déploiement sera lancé à l’aide de la configuration de déploiement nodejs-mongodb-exemple.

       • Le pipeline attendra jusqu’à ce que le déploiement soit terminé pour déclencher la prochaine étape.
     • En cas de succès de la construction et du déploiement, l’image nodejs-mongodb-example:dernière image sera marquée comme nodejs-mongodb-example:stage.

   • La gousse d’agent est supprimée, si l’on en avait besoin pour le pipeline.

     Note

     La meilleure façon de visualiser l’exécution du pipeline est de l’afficher dans le Red Hat OpenShift Service sur la console web AWS. Consultez vos pipelines en vous connectant à la console Web et en naviguant vers Builds Pipelines.