Paip Jenkins sederhana dengan Marathon dan Mesos

1. Pengenalan

Dalam artikel ini, kami akan melaksanakan saluran paip Penghantaran Berterusan sederhana dengan Jenkins, Marathon dan Mesos.

Pertama, kami akan memberikan gambaran tahap tinggi mengenai timbunan teknologi dan seni bina, dengan penjelasan bagaimana semuanya sesuai. Berikutan itu, kita akan menuju contoh praktikal dan langkah demi langkah.

Hasil dari ini akan menjadi saluran paip Jenkins automatik, menyebarkan aplikasi kami ke kelompok Mesos kami menggunakan Marathon.

2. Gambaran Keseluruhan Tumpuan Teknologi

Semasa bekerja dengan kontena dan arsitektur perkhidmatan mikro, kami menghadapi masalah operasi baru yang tidak akan kami lakukan dengan timbunan yang lebih tradisional.

Sebagai contoh, ketika menggunakan kluster, kita harus berurusan dengan penskalaan, failover, rangkaian dan banyak lagi. Masalah pengkomputeran yang sukar dan diedarkan ini dapat diselesaikan dengan kernel dan penjadual yang diedarkan, seperti Apache Mesos dan Marathon.

2.1. Mesos

Mesos, dalam istilah yang paling sederhana, dapat dilihat sebagai pelayan tunggal di mana aplikasi kami akan dijalankan. Pada hakikatnya, kita mempunyai kelompok, tetapi pengabstrakan inilah yang menjadikannya sangat berguna.

2.2. Maraton

Marathon adalah kerangka yang digunakan untuk menyebarkan aplikasi kami ke Mesos, menyelesaikan masalah sukar bagi kami (pemeriksaan kesihatan, penskalaan otomatis, failover, pemantauan dll).

3. Persediaan dan Pemasangan

Artikel ini menganggap anda sudah menjalankan Jenkins, Mesos dan Marathon. Sekiranya ini tidak berlaku, baca dokumentasi rasmi untuk masing-masing untuk mengetahui cara menyiapkannya. Tanpa ini, anda tidak akan dapat melaksanakan langkah-langkah dalam panduan ini.

4. Paip Penghantaran Kami

Kami akan membuat saluran paip Jenkins berikut:

Tidak ada yang sangat rumit mengenai pendekatan ini - ia identik dengan aliran saluran paip CD moden anda. Dalam kes kami, membangun akan bermaksud memuatkan aplikasi, dan menyebarkan akan bermaksud menggunakan Marathon untuk menjadwalkannya pada kelompok Mesos.

5. Menguji dan Membangunkan Aplikasi Kami

Langkah pertama adalah membina dan menguji aplikasi kita. Untuk mempermudah, aplikasi yang akan kami kerjakan adalah aplikasi Spring Boot. Oleh kerana itu, artifak yang dihasilkan akan menjadi balang yang dapat dilaksanakan. Ia tidak akan mempunyai kebergantungan luaran selain JRE, menjadikannya sangat mudah untuk dilaksanakan.

5.1. Menciptakan Tugas Kita

Perkara pertama yang ingin kita lakukan ialah mewujudkan pekerjaan Jenkins kita. Mari pilih "Item Baru" di bar navigasi sebelah kiri, kemudian pilih buat projek gaya bebas, menamakannya " marathon-mesos-demo " :

5.2. Bersepadu dengan Git

Seterusnya, mari konfigurasikannya untuk mengklon repositori Github yang mengandungi aplikasi kami:

Demi kesederhanaan, repositori kami adalah umum, yang bermaksud bahawa kami dapat mengklon melalui https . Sekiranya ini tidak berlaku dan kami mengklon SSH, akan ada langkah tambahan untuk menyiapkan pengguna SSH dan kunci peribadi, di luar ruang lingkup artikel ini.

5.3. Menyiapkan Pencetus Binaan

Seterusnya, mari sediakan beberapa pencetus binaan supaya tugas kami akan membuat tinjauan untuk komitmen baru setiap minit:

5.4. Menjana Skrip Bina Kami

Kita sekarang dapat memberitahu tugas kita untuk melaksanakan skrip shell ketika ia berjalan. Semasa kami bekerja dengan projek Spring Boot Maven yang sederhana, yang perlu kami lakukan adalah menjalankan perintah " mvn clean install ". Ini akan menjalankan semua ujian, dan membina balang boleh laku kami :

5.5. Membangunkan Projek Kami

Sekarang kita telah mengatur permulaan saluran paip kita, mari kita mencetuskannya secara manual dengan mengklik "Bangun Sekarang" di tempat kerja. Setelah tugas selesai, kami dapat mengesahkan bahawa tugas itu telah dilaluinya ditandai sebagai biru.

6. Mengandungi Aplikasi Kami

Mari kita melangkah ke tahap berikutnya dari saluran paip kita, iaitu mengemas dan menerbitkan aplikasi kita dengan Docker. Kita perlu menggunakan Docker kerana wadah khusus yang dikendalikan oleh Marathon. Ini tidak masuk akal, kerana hampir semua perkara boleh berjalan di dalam bekas. Lebih mudah bagi alat seperti Marathon untuk bekerja dengan pengabstrakan yang diberikan oleh alat ini.

6.1. Membuat Dockerfile

Pertama, mari buat Dockerfile di root projek. Pada dasarnya, Dockerfile adalah fail yang mengandungi arahan kepada Docker Deamon mengenai cara membina gambar:

FROM openjdk:8-jre-alpine ADD target/mesos-marathon-0.0.1-SNAPSHOT.jar app.jar EXPOSE 8082 ENTRYPOINT ["java","-jar","/app.jar"]

The image we are building is simple – all it contains is an executable jar and a shell command which will execute it when the container starts. We also have to make sure that we are exposing the port that our application will listen on, in this case ‘8082'.

6.2. Publishing the Image

Now that we are able to build our image, let's create a simple bash script which builds and publishes it to our private Docker Hub repository, and put it in our project root:

#!/usr/bin/env bash set -e docker login -u baeldung -p $DOCKER_PASSWORD docker build -t baeldung/mesos-marathon-demo:$BUILD_NUMBER . docker push baeldung/mesos-marathon-demo:$BUILD_NUMBER 

You might need to push your image to the public docker registry or your private one.

The $BUILD_NUMBER environment variable is populated by Jenkins, incrementing with every build. Although slightly brittle, it is a quick way of getting each build to increase in version number. The $DOCKER_PASSWORD is also populated by Jenkins, and in this case, we will make use of the EnvInject plugin in order to keep it secret.

Whilst we could store this script directly in Jenkins, it's better practice for it to remain in version control, as it can then be versioned and audited alongside the rest of our project.

6.3. Building and Publishing on Jenkins

Now let's modify our Jenkins job so it runs “Dockerise.sh” after building the jar:

And then, let's run our job to confirm again, confirming everything is working by it going blue.

7. Deploying Our Image

Our pipeline is nearly complete. There is only one more stage, which is to use Marathon to deploy our application to our Mesos cluster.

Jenkins comes with a “Deploy with Marathon” plugin. This acts as a wrapper around the Marathon API, making it easier than it would be when working with traditional shell scripting. You can install it via the plugin manager.

7.1. Creating Our Marathon.Json File

Before we can use the Marathon plugin, we need to create a “marathon.json” file, and store it in our project root. This is because the plugin is dependent on it.

This file: “marathon.json” contains a Mesos Application Definition. This is a description of a long-running service (application) that we want to run. Ultimately, the Jenkins Marathon plugin will POST the contents of the file to the Marathon /v2/apps endpoint. Marathon will then in turn schedule the defined application to run on Mesos:

{ "id": "mesos-marathon-demo", "container": { "type": "DOCKER", "docker": { "image": "", "network": "BRIDGE", "portMappings": [ { "containerPort": 8082, "hostPort": 0 } ] } } }

This is the simplest configuration we can give for a containerized application.

The property: “portMappings” needs to be set correctly in order to make our application accessible from our Mesos slave. It basically means, map the container port 8082, to a random port on the host (mesos slave) so we can talk to our application from the outside world. After deploying our application, Marathon will tell us what that port used.

7.2. Adding a Marathon Deployment Build Step

Let's add a Marathon Deployment post build action to our job:

Notice we're telling the plugin where Marathon is running, in this case ‘localhost:8081'. We're also telling it the image we want to deploy. This is what the empty “image” field in our file get's replaced with.

Now we've created the final stage of our pipeline, let's run our job one more time and confirm that it's still passing, this time with the extra step where it sends our application to Marathon.

7.3. Verifying Our Deployment in Marathon

Now it's been deployed, let's take a look in the Marathon UI:

As we can see, our application is now shown in the UI. In order to access it, we just need to check what host and port it has been assigned:

Dalam kes ini, pelabuhan 31143 telah diperuntukkan secara rawak di localhost, yang secara dalaman akan memetakan ke port 8082 di bekas kami seperti yang dikonfigurasi dalam definisi aplikasi. Kami kemudian boleh mengunjungi URL ini di penyemak imbas kami untuk mengesahkan aplikasi dilayan dengan betul.

8. Kesimpulannya

Dalam artikel ini, kami telah membuat saluran paip Penghantaran Berterusan sederhana menggunakan Jenkins, Marathon, dan Mesos. Setiap kali kami melakukan perubahan pada kod kami, kode tersebut akan berjalan di persekitaran beberapa minit kemudian.

Artikel kemudian dalam siri ini akan merangkumi topik Maraton yang lebih maju, seperti pemeriksaan kesihatan aplikasi, penskalaan, failover. Kes penggunaan lain untuk Mesos, seperti pemprosesan kumpulan juga boleh dilindungi.

Kod sumber untuk aplikasi kami boleh didapati di GitHub; ini adalah projek Maven yang seharusnya dapat dijalankan seperti sedia kala.