Pianificazione di un lavoro a Jenkins

1. Introduzione

In questo articolo, tratteremo vari modi di pianificare i lavori in Jenkins.

Inizieremo con la pianificazione di un lavoro semplice che esegue qualcosa di semplice come stampare un messaggio di testo normale. E svilupperemo l'esempio nella pianificazione di un lavoro che viene automaticamente attivato dalle modifiche in un repository SCM come GitHub, Bitbucket, ecc.

2. Configurazione iniziale

Si presume che JDK e Maven siano stati installati in Global Tool Configuration con nomi come JDK9.0.1 e Maven3.5.2 , rispettivamente, sul server Jenkins.

Si presume inoltre che abbiamo accesso a un repository SCM come Bitbucket con un progetto Maven configurato correttamente.

3. Pianificazione di un lavoro semplice

Nella pagina di configurazione del lavoro, scorriamo verso il basso fino alla sezione Build Triggers . Poiché intendiamo creare un lavoro semplice, selezioniamo la casella di controllo contrassegnata Crea periodicamente . Non appena selezioniamo questa casella di controllo, viene visualizzata una casella di testo con l' etichetta Programma .

Dobbiamo fornire valore in un formato conforme a Cron . Sono disponibili ampie informazioni sulla pagina se si fa clic sul punto interrogativo accanto alla casella.

Digita * / 2 * * * * qui, che rappresenta un intervallo di due minuti:

Dopo aver eliminato la scheda dalla casella di testo, possiamo vedere le informazioni proprio sotto la casella. Ci dice quando verrà eseguito il lavoro successivo.

Salviamo il lavoro - in circa due minuti, dovremmo vedere lo stato della prima esecuzione del lavoro:

Poiché abbiamo configurato il lavoro per essere eseguito ogni due minuti, dovremmo vedere più numeri di build quando torniamo alla dashboard del lavoro dopo aver atteso un po 'di tempo.

4. Creazione di un lavoro che esegue il polling di SCM

Facciamo un passo avanti e creiamo un lavoro che estrae il codice sorgente dal repository SCM come Bitbucket ed esegue una compilazione.

Creiamo un nuovo lavoro come spiegato nella sezione precedente, con alcune modifiche.

Nella sezione Build Triggers , invece di selezionare Build Periodically , selezioniamo Poll SCM . Non appena lo facciamo, dovremmo vedere una casella di testo con Label Schedule .

Digita * / 5 * * * * in questa casella, il che significa che vogliamo pianificare l'esecuzione del lavoro ogni 5 minuti:

Scorriamo fino alla sezione Gestione del codice sorgente . Dopo aver selezionato il pulsante di opzione accanto a Git , viene visualizzata una nuova sezione etichettata come Repository .

Qui è dove dobbiamo configurare i dettagli del nostro repository SCM . Digita l'URL del repository SCM nel campo di testo URL del repository :

Dobbiamo anche fornire le credenziali utente in modo che Jenkins possa accedere al repository.

Facciamo clic sul pulsante Aggiungi accanto a Credenziali, che visualizzerà una schermata a comparsa per creare le credenziali dell'utente.

Selezioniamo il tipo come nome utente con password . Dovremo digitare il nome utente e la password nei campi di testo designati:

Facendo clic sul pulsante Aggiungi , torniamo alla sezione Gestione del codice sorgente .

Selezioniamo questa credenziale utente nel menu a discesa accanto a Credenziali :

L'ultima cosa che dobbiamo fare è impostare lo script di compilazione.

Scorriamo verso il basso fino alla sezione Build , fai clic su Add build step e seleziona Execute Shell . Dato che stiamo lavorando a un progetto Maven nel repository SCM, dobbiamo digitare mvn clean install , che eseguirà una build Maven.

Cerchiamo di capire cosa abbiamo fatto qui.

Abbiamo creato un lavoro che dovrebbe essere eseguito ogni 5 minuti. Il lavoro è stato configurato per estrarre il codice sorgente dal ramo principale del repository Bitbucket specificato .

Utilizzerà le credenziali utente fornite per accedere a Bitbucket.

Dopo aver estratto il codice sorgente, il lavoro eseguirà lo script contenente un comando Maven fornito.

Ora, se salviamo e aspettiamo circa cinque minuti, dovremmo vedere l'esecuzione della build nella sezione Build History sul dashboard del lavoro.

L' output della console dovrebbe mostrare l'output della build Maven. Possiamo vedere nell'output della console che il codice sorgente è stato estratto da Bitbucket ed è stato eseguito il comando mvn clean install :

Poiché si tratta di una build Maven, l'output della console potrebbe essere molto lungo a seconda del numero di dipendenze Maven scaricate .

Ma alla fine dell'output, dovremmo vedere il messaggio BUILD SUCCESS .

5. Creazione di un lavoro che utilizza la pipeline come script

Finora, abbiamo visto come creare lavori che vengono eseguiti all'orario programmato predefinito.

Ora creiamo un lavoro che non sia vincolato a una pianificazione particolare. Invece, lo configureremo in modo che si attivi automaticamente ogni volta che c'è un nuovo commit nel repository SCM.

Tornando alla dashboard di Jenkins, facciamo clic su Nuovo elemento . Questa volta, invece del progetto Freestyle , selezioneremo Pipeline . Chiamiamo questo lavoro PipelineAsScriptJob.

Upon clicking OK button, we'll be taken to the pipeline configuration page. This page has several sections such as “General”, “Build Triggers”, “Advanced Project Options”, and “Pipeline”.

Let's scroll down to “Build Triggers” section and the select checkbox next to Build when a change is pushed to Bitbucket. This option will be available only if we've installed the Bitbucket Plugin:

Let's scroll down to Pipeline section. We need to select Pipeline Script in the drop-down next to Definition.

The Text Box just below this drop-down is waiting for the script to be placed in. There're two ways of doing this.

We can either type the whole script, or we can make use of a utility provided by Jenkins, which is known as Pipeline Syntax.

Let's choose the second option:

On click of Pipeline Syntax, as highlighted in the diagram above, a new tab opens up in the browser. This is a handy utility where we can specify the operation that we wish to perform, and the tool will generate the script in Groovy for us. We can then copy the script and paste it into the pipeline configuration.

Let's select checkout: General SCM in the Sample Step drop-down. After providing the SCM Repo URL and user credentials, we need to click the Generate Pipeline Script button.

This generates the script in the text box:

Let's copy this script and save it somewhere for later use.

On the same page, let's scroll up and select withMaven: Provide Maven environment in the Sample Step drop-down. It must be noted here, that this option will be available only if Pipeline Maven Integration Plugin is installed.

We need to select the names of Maven and JDK installations next to the corresponding drop-downs. We need to click the Generate Pipeline Script button.

This generates the script in the text box:

Let's save the script.

There are still a few more scripts that we need to generate. Let's select node: Allocate node in the Sample Step drop-down, type master in the Label text field and click Generate Pipeline Script:

Let's save the script.

And last one.

Let's select stage: Stage in the Sample Step drop-down, type scm in the Stage Name text field and click Generate Pipeline Script:

Let's save it.

It's time to collate all the scripts generated so far and stitch them together:

node('master') { stage('scm') { checkout([$class: 'GitSCM', branches: [[name: '*/master']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'e50f564f-fbb7-4660-9c95-52dc93fa26f7', url: '//[email protected]/projects/springpocrepo.git']]]) } stage('build') { withMaven(jdk: 'JDK9.0.1', maven: 'Maven3.5.2') { sh 'mvn clean install' } } }

The first statement, node(‘master') in the script above, indicates that the job will be executed on a node named master, which is the default node on the Jenkins server.

Let's copy the above script to the Text Box in Pipeline section:

Let's save this configuration.

Now, there's only one thing that's left out. We need to configure a Webhook in Bitbucket. The Webhook is responsible for sending out a push notification to Jenkins server, whenever a particular event takes place in Bitbucket.

Let's take a look at how to configure it.

Let's log in to Bitbucket and select a repository. We should see an option Settings on the left-hand side column. Let's click it, and we should see an option Webhooks in WORKFLOW section. Let's create a new Webhook.

We need to provide some name to this webhook in the Title field. We also need to provide a URL for the webhook in the URL field. This URL needs to point to one particular REST API Endpoint provided by Jenkins, and that endpoint is bitbucket-hook.

It must be noted that the URL MUST end with a trailing slash:

While configuring the Webhook above, we've selected option Repository push. This means Bitbucket will send a notification to Jenkins server whenever a push happens.

This behavior can be modified; there are several different options to choose from.

For now, let's go with the default option,i.e., Repository Push.

We can setup webhook in Github, too; here‘s some helpful information on how to configure that.

Long story short: we've created a pipeline script in Groovy language – that should pull the source code from the master branch of the provided SCM repository (using the provided user credentials), whenever there's a push in the repository and then execute mvn clean install command on the Jenkins server.

It must be noted that this job's not going to run at any particular time. Instead, it's going to wait till there's a push in the master branch of the SCM repository.

As soon as there's a new push event, we'll see a new execution in the “Build History” section on the Jenkins job dashboard.

We should see a new build being initiated with a pending status next to it.

In a few seconds, this build should start execution, and we'll be able to see the complete log in Console Output.

The first statement in the console output says “Started by Bitbucket push by..” – this means that the build was triggered automatically when a Push took place in Bitbucket:

If all goes well, the build should complete successfully.

6. Create a Job That Uses Jenkinsfile

It's possible NOT to write any script in the Jenkins pipeline and still achieve build execution being triggered by the Bitbucket Webhook.

To do so, we have to create a new file in Bitbucket and name it as Jenkinsfile. The pipeline script needs to be transferred to this Jenkinsfile with a slight modification. Let's see exacttly how to do that.

We'll create a new pipeline in Jenkins and name it PipelineWithJenkinsfile.

On the pipeline configuration page, we'll select Pipeline script from SCM next to Definition in the Pipeline section. We'll see a drop-down with different options next to SCM. Let's choose Git from the drop-down.

We then have to provide the URL of Bitbucket repository and user credentials. Let's ensure that the text field next to Script Path contains the default value,i.e., Jenkinsfile:

As far as Jenkins is concerned, that's all we need to configure.

However, we have to create the Jenkinsfile in the repository; so, let's create a new text file, name it as Jenkinsfile and use this simple groovy script:

node('master') { stage('scm') { checkout scm } stage('build') { withMaven(jdk: 'JDK9.0.1', maven: 'Maven3.5.2') { sh 'mvn clean install' } } }

This script is almost the same as the pipeline script that we created in the earlier section, with just one modification. The statement in stage(‘scm') doesn't need the URL and user credentials information. Instead, all it needs is checkout scm.

And that's it. The moment we commit this file into Bitbucket, it'll trigger the build in Jenkins – and we should see the build being triggered in the Build History.

The only difference between this section and the earlier one is that we defined the pipeline script in the Bitbucket repository.

Quindi, lo script di compilazione fa parte del codice sorgente del progetto che deve essere compilato . Non stiamo mantenendo la sceneggiatura in Jenkins stesso.

Jenkins è invece a conoscenza dei dettagli del repository SCM e del file di script. Ogni volta che viene effettuato un push a questo repository, lo script in Jenkinsfile viene eseguito sul server Jenkins .

7. Conclusione

In questo tutorial, abbiamo visto come i lavori possono essere configurati e programmati in Jenkins utilizzando varie strategie.

Abbiamo anche visto come configurare un lavoro in Jenkins in modo che venga attivato automaticamente, in base a determinate azioni eseguite nel repository SCM come Bitbucket.