Menjadwalkan Pekerjaan di Jenkins

1. Perkenalan

Pada artikel ini, kami akan membahas berbagai cara penjadwalan pekerjaan di Jenkins.

Kami akan mulai dengan menjadwalkan pekerjaan sederhana yang melakukan sesuatu yang sederhana seperti mencetak pesan teks biasa. Dan kami akan mengembangkan contoh menjadi penjadwalan pekerjaan yang secara otomatis dipicu oleh perubahan dalam repositori SCM seperti GitHub, Bitbucket, dll.

2. Pengaturan Awal

Kami berasumsi bahwa JDK dan Maven telah diinstal di Konfigurasi Alat Global dengan nama masing-masing sebagai JDK9.0.1 dan Maven3.5.2 , di server Jenkins.

Ini juga mengasumsikan bahwa kita memiliki akses ke repositori SCM seperti Bitbucket dengan proyek Maven yang diatur dengan benar.

3. Menjadwalkan Pekerjaan Sederhana

Di halaman konfigurasi pekerjaan, mari gulir ke bawah langsung ke bagian Pemicu Build . Karena kami bermaksud membuat pekerjaan langsung, mari pilih kotak centang bertanda Build secara berkala . Segera setelah kami memilih kotak centang ini, Kotak Teks ditampilkan dengan label Jadwal .

Kami harus memberikan nilai dalam format yang sesuai dengan Cron . Ada banyak informasi yang tersedia di halaman tersebut jika kita mengklik tanda tanya di sebelah kotak.

Mari ketik * / 2 * * * * di sini, yang mewakili interval dua menit:

Setelah keluar dari kotak teks, kita dapat melihat informasi tepat di bawah kotak. Ini memberi tahu kita tentang kapan pekerjaan akan berjalan selanjutnya.

Mari selamatkan pekerjaan - dalam waktu sekitar dua menit, kita akan melihat status eksekusi pekerjaan yang pertama:

Karena kita telah mengonfigurasi pekerjaan untuk dijalankan setiap dua menit, kita akan melihat beberapa nomor build saat kita kembali ke dasbor pekerjaan setelah menunggu beberapa saat.

4. Membuat Pekerjaan Yang Memungut Suara SCM

Mari bergerak selangkah lebih maju dan membuat pekerjaan yang mengambil kode sumber dari repositori SCM seperti Bitbucket dan melakukan build.

Mari buat pekerjaan baru seperti yang dijelaskan di bagian sebelumnya, dengan sedikit modifikasi.

Di bagian Build Triggers , daripada memilih Build Periodically , mari pilih Poll SCM . Segera setelah kita melakukannya, kita akan melihat kotak teks dengan Label Schedule .

Mari ketik * / 5 * * * * di kotak ini, yang berarti kita ingin menjadwalkan pekerjaan untuk dijalankan setiap 5 menit:

Mari gulir ke atas ke bagian Manajemen Kode Sumber . Setelah memilih tombol radio di sebelah Git , bagian baru muncul dengan label Repositories .

Di sinilah kita perlu mengonfigurasi detail repositori SCM kita . Mari ketik URL repositori SCM di kolom teks Repository URL :

Kami juga perlu memberikan kredensial pengguna agar Jenkins dapat mengakses repositori.

Mari klik tombol Add di sebelah Kredensial, yang akan menampilkan layar pop-up untuk membuat kredensial pengguna.

Mari pilih Jenis sebagai Nama Pengguna dengan Kata Sandi . Kami harus mengetikkan nama pengguna dan kata sandi di bidang teks yang ditentukan:

Saat mengklik tombol Add , kita dibawa kembali ke bagian Source Code Management .

Mari pilih kredensial pengguna ini di drop-down di sebelah Kredensial :

Sekarang, hal terakhir yang perlu kita lakukan adalah menyiapkan skrip build.

Mari gulir ke bawah ke bagian Build , klik Add build step dan pilih Execute Shell . Karena kita sedang mengerjakan proyek Maven di repositori SCM, kita perlu mengetik mvn clean install , yang akan menjalankan build Maven.

Mari kita coba memahami apa yang telah kita lakukan di sini.

Kami telah membuat pekerjaan yang dijadwalkan untuk dijalankan setiap 5 menit. Pekerjaan telah dikonfigurasi untuk mengambil kode sumber dari cabang master dari repositori Bitbucket yang diberikan .

Ini akan menggunakan kredensial pengguna yang disediakan untuk masuk ke Bitbucket.

Setelah menarik kode sumber, tugas tersebut akan menjalankan skrip yang berisi perintah Maven yang disediakan.

Sekarang, jika kita menyimpan dan menunggu kurang lebih lima menit, kita akan melihat eksekusi build di bagian Build History pada dasbor pekerjaan.

The Console Keluaran harus menunjukkan output dari Maven membangun. Kita dapat melihat di output konsol bahwa kode sumber telah ditarik dari Bitbucket dan perintah mvn clean install telah dijalankan:

Karena ini adalah build Maven, keluaran konsol mungkin sangat panjang tergantung pada jumlah dependensi Maven yang diunduh .

Tetapi di akhir keluaran, kita akan melihat pesan BUILD SUCCESS .

5. Membuat Pekerjaan Yang Menggunakan Pipeline sebagai Script

Sejauh ini, kita telah melihat cara membuat pekerjaan yang dijalankan pada waktu yang telah ditentukan sebelumnya.

Sekarang, mari buat pekerjaan yang tidak terikat dengan jadwal tertentu. Sebagai gantinya, kami akan mengonfigurasinya untuk secara otomatis memicu setiap kali ada komit baru di repositori SCM.

Kembali ke dasbor Jenkins, klik Item Baru . Kali ini, alih-alih proyek Freestyle , kami akan memilih Pipeline . Beri nama pekerjaan ini PipelineAsScriptJob.

Setelah mengklik tombol OK, kita akan dibawa ke halaman konfigurasi pipeline. Halaman ini memiliki beberapa bagian seperti " Umum" , " Pemicu Build" , " Opsi Proyek Lanjutan" , dan " Saluran Pipa" .

Mari scroll ke bawah ke bagian " Build Triggers" dan pilih kotak centang di sebelah Build ketika perubahan didorong ke Bitbucket . Opsi ini hanya akan tersedia jika kami telah menginstal Plugin Bitbucket :

Mari gulir ke bawah ke bagian Pipeline . Kita perlu memilih Pipeline Script di drop-down di sebelah Definisi .

Kotak Teks tepat di bawah tarik-turun ini menunggu skrip ditempatkan. Ada dua cara untuk melakukan ini.

Kita bisa mengetik seluruh skrip, atau kita bisa menggunakan utilitas yang disediakan oleh Jenkins, yang dikenal sebagai Pipeline Syntax .

Mari pilih opsi kedua:

Saat mengklik Pipeline Syntax , seperti yang disorot pada diagram di atas, tab baru akan terbuka di browser. Ini adalah utilitas praktis di mana kita dapat menentukan operasi yang ingin kita lakukan, dan alat tersebut akan membuat skrip di Groovy untuk kita. Kami kemudian dapat menyalin skrip dan menempelkannya ke konfigurasi pipeline.

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.

Jadi, skrip build adalah bagian dari kode sumber proyek yang perlu dibangun . Kami tidak mengelola skrip di Jenkins itu sendiri.

Sebaliknya, Jenkins memiliki pengetahuan tentang detail repositori SCM dan file skrip. Setiap kali ada dorongan ke repositori ini, skrip di Jenkinsfile dijalankan di server Jenkins .

7. Kesimpulan

Dalam tutorial ini, kita telah melihat bagaimana pekerjaan dapat dikonfigurasi dan dijadwalkan di Jenkins menggunakan berbagai strategi.

Kami juga telah melihat cara mengonfigurasi pekerjaan di Jenkins agar dipicu secara otomatis, berdasarkan tindakan tertentu yang dilakukan di repositori SCM seperti Bitbucket.