GSP051

Ringkasan

Di lab ini, Anda akan mempelajari cara menyiapkan pipeline continuous delivery dengan Jenkins di Kubernetes engine. Jenkins adalah server otomatisasi andalan para developer yang sering mengintegrasikan kode dalam repositori bersama. Solusi yang akan Anda buat di lab ini akan serupa dengan diagram berikut:

Di Cloud Architecture Center, lihat Jenkins di Kubernetes Engine untuk mempelajari lebih lanjut cara menjalankan Jenkins di Kubernetes.

Yang akan Anda pelajari

Di lab ini, Anda akan menyelesaikan tugas-tugas berikut untuk mempelajari cara menjalankan Jenkins di Kubernetes:

• Menyediakan aplikasi Jenkins ke dalam Cluster Kubernetes Engine
• Menyiapkan aplikasi Jenkins menggunakan Helm Package Manager
• Mempelajari fitur-fitur aplikasi Jenkins
• Membuat dan menggunakan pipeline Jenkins

Prasyarat

Ini adalah lab tingkat lanjut. Sebelum mengikutinya, Anda harus setidaknya sudah memahami dasar-dasar pemrograman shell, Kubernetes, dan Jenkins. Berikut adalah beberapa lab yang dapat melengkapi pengetahuan Anda:

• Pengantar Docker
• Memahami Node Kubernetes
• Mengelola Deployment Menggunakan Kubernetes Engine
• Menyiapkan Jenkins di Kubernetes Engine

Setelah Anda siap, scroll ke bawah untuk mempelajari Kubernet, Jenkins, dan Continuous Delivery lebih lanjut.

Apa yang dimaksud dengan Kubernetes Engine?

Kubernetes Engine adalah versi Kubernetes yang dihosting oleh Google Cloud dan merupakan sistem pengelola cluster dan orkestrasi container yang canggih. Kubernetes adalah project open source yang dapat berjalan di berbagai lingkungan, dari laptop hingga cluster multinode dengan ketersediaan tinggi, dari virtual machine hingga server khusus (bare metal). Seperti yang disebutkan sebelumnya, aplikasi Kubernetes dibuat di container, yaitu aplikasi ringan yang dipaketkan dengan semua dependensi dan library yang diperlukan untuk menjalankannya. Struktur dasar ini menyediakan aplikasi Kubernetes yang aman, cepat di-deploy, dan memiliki ketersediaan tinggi, sehingga menjadikannya sebuah framework yang ideal untuk developer cloud.

Apa yang dimaksud dengan Jenkins?

Jenkins adalah server otomatisasi open source yang memungkinkan Anda mengorkestrasi pipeline build, pengujian, dan deployment secara fleksibel. Jenkins memungkinkan developer untuk melakukan iterasi pada project secara cepat tanpa perlu mengkhawatirkan masalah overhead yang dapat muncul dari continuous delivery.

Apa yang dimaksud dengan Continuous Delivery/Deployment Berkelanjutan?

Jika Anda harus menyiapkan pipeline continuous delivery (CD), men-deploy Jenkins di Kubernetes Engine akan memberikan lebih banyak manfaat penting dibandingkan dengan deployment berbasis VM standar.

Jika proses build Anda menggunakan container, satu host virtual dapat menjalankan tugas di beberapa sistem operasi. Kubernetes Engine menyediakan ephemeral build executors yang hanya digunakan ketika build aktif berjalan, sehingga meninggalkan resource untuk tugas cluster lainnya seperti tugas batch processing. Manfaat lain dari ephemeral build executors ialah kecepatan, sehingga proses peluncuran berlangsung hanya dalam hitungan detik.

Kubernetes Engine juga dilengkapi dengan load balancer global Google yang dapat Anda gunakan untuk mengotomatiskan perutean traffic web ke instance. Load balancer menangani penghentian SSL dan menggunakan alamat IP global yang dikonfigurasikan dengan jaringan backbone Google. Jika digunakan bersama web front, load balancer ini akan selalu menempatkan pengguna di jalur tercepat ke instance aplikasi.

Setelah Anda mempelajari sedikit tentang Kubernetes, Jenkins, dan cara keduanya berinteraksi dalam pipeline CD, sekarang saatnya untuk membuatnya.

Penyiapan dan persyaratan

Sebelum mengklik tombol Mulai Lab

Baca petunjuk ini. Lab memiliki timer dan Anda tidak dapat menjedanya. Timer, yang dimulai saat Anda mengklik Start Lab, akan menampilkan durasi ketersediaan resource Google Cloud untuk Anda.

Lab praktik ini dapat Anda gunakan untuk melakukan sendiri aktivitas lab di lingkungan cloud sungguhan, bukan di lingkungan demo atau simulasi. Untuk mengakses lab ini, Anda akan diberi kredensial baru yang bersifat sementara dan dapat digunakan untuk login serta mengakses Google Cloud selama durasi lab.

Untuk menyelesaikan lab ini, Anda memerlukan:

• Akses ke browser internet standar (disarankan browser Chrome).

Catatan: Gunakan jendela Samaran atau browser pribadi untuk menjalankan lab ini. Hal ini akan mencegah konflik antara akun pribadi Anda dan akun Siswa yang dapat menyebabkan tagihan ekstra pada akun pribadi Anda.

• Waktu untuk menyelesaikan lab. Ingat, setelah dimulai, lab tidak dapat dijeda.

Catatan: Jika Anda sudah memiliki project atau akun pribadi Google Cloud, jangan menggunakannya untuk lab ini agar terhindar dari tagihan ekstra pada akun Anda.

Cara memulai lab dan login ke Google Cloud Console

1. Klik tombol Start Lab. Jika Anda perlu membayar lab, jendela pop-up akan terbuka untuk memilih metode pembayaran. Di sebelah kiri adalah panel Lab Details dengan info berikut:

   • Tombol Open Google Cloud console
   • Waktu tersisa
   • Kredensial sementara yang harus Anda gunakan untuk lab ini
   • Informasi lain, jika diperlukan, untuk menyelesaikan lab ini

2. Klik Open Google Cloud console (atau klik kanan dan pilih Open Link in Incognito Window jika Anda menjalankan browser Chrome).

   Lab akan menjalankan resource, lalu membuka tab lain yang menampilkan halaman Sign in.

   Tips: Atur tab di jendela terpisah secara berdampingan.

   Catatan: Jika Anda melihat dialog Choose an account, klik Use Another Account.

3. Jika perlu, salin Username di bawah dan tempel ke dialog Sign in.

   {{{user_0.username | "Username"}}}

   Anda juga dapat menemukan Username di panel Lab Details.

4. Klik Next.

5. Salin Password di bawah dan tempel ke dialog Welcome.

   {{{user_0.password | "Password"}}}

   Anda juga dapat menemukan Password di panel Lab Details.

6. Klik Next.

   Penting: Anda harus menggunakan kredensial yang diberikan lab. Jangan menggunakan kredensial akun Google Cloud Anda. Catatan: Menggunakan akun Google Cloud sendiri untuk lab ini dapat dikenai biaya tambahan.

7. Klik halaman berikutnya:

   • Setujui persyaratan dan ketentuan.
   • Jangan tambahkan opsi pemulihan atau autentikasi 2 langkah (karena ini akun sementara).
   • Jangan mendaftar uji coba gratis.

Setelah beberapa saat, Konsol Google Cloud akan terbuka di tab ini.

Catatan: Untuk melihat menu dengan daftar produk dan layanan Google Cloud, klik Navigation menu di kiri atas.

Mengaktifkan Cloud Shell

Cloud Shell adalah mesin virtual yang dilengkapi dengan berbagai alat pengembangan. Mesin virtual ini menawarkan direktori beranda persisten berkapasitas 5 GB dan berjalan di Google Cloud. Cloud Shell menyediakan akses command-line untuk resource Google Cloud Anda.

1. Klik Activate Cloud Shell di bagian atas konsol Google Cloud.

Setelah terhubung, Anda sudah diautentikasi, dan project ditetapkan ke PROJECT_ID Anda. Output berisi baris yang mendeklarasikan PROJECT_ID untuk sesi ini:

Project Cloud Platform Anda dalam sesi ini disetel ke YOUR_PROJECT_ID

gcloud adalah alat command line untuk Google Cloud. Alat ini sudah terinstal di Cloud Shell dan mendukung pelengkapan command line.

2. (Opsional) Anda dapat menampilkan daftar nama akun yang aktif dengan perintah ini:

gcloud auth list

3. Klik Authorize.

4. Output Anda sekarang akan terlihat seperti ini:

Output:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net Untuk menyetel akun aktif, jalankan: $ gcloud config set account `ACCOUNT`

5. (Opsional) Anda dapat menampilkan daftar project ID dengan perintah ini:

gcloud config list project

Output:

[core] project = <project_ID>

Contoh output:

[core] project = qwiklabs-gcp-44776a13dea667a6 Catatan: Untuk mendapatkan dokumentasi gcloud yang lengkap di Google Cloud, baca panduan ringkasan gcloud CLI.

Tugas 1. Mendownload kode sumber

1. Sebagai persiapan, buka sesi baru di Cloud Shell dan jalankan perintah berikut untuk menetapkan zona Anda :

gcloud config set compute/zone {{{project_0.default_zone}}}

2. Lalu, salin kode contoh lab:

gsutil cp gs://spls/gsp051/continuous-deployment-on-kubernetes.zip . unzip continuous-deployment-on-kubernetes.zip

3. Selanjutnya, ubah ke direktori yang benar:

cd continuous-deployment-on-kubernetes

Tugas 2. Menyediakan Jenkins

Membuat Cluster Kubernetes

1. Sekarang, jalankan perintah berikut untuk menyediakan 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"

Langkah ini dapat memakan waktu beberapa menit. Cakupan ekstra memungkinkan Jenkins mengakses Cloud Source Repositories dan Google Container Registry.

Menguji tugas yang sudah selesai

Klik Check my progress untuk memverifikasi tugas yang telah diselesaikan. Jika cluster Kubernetes berhasil dibuat, Anda akan melihat skor penilaian.

Membuat cluster Kubernetes (zona: )

2. Sebelum melanjutkan, konfirmasi bahwa cluster Anda berjalan dengan menjalankan perintah berikut:

gcloud container clusters list

3. Sekarang, dapatkan kredensial untuk cluster Anda:

gcloud container clusters get-credentials jenkins-cd

4. Kubernetes Engine menggunakan kredensial ini untuk mengakses cluster yang baru disediakan. Pastikan Anda dapat menghubungkannya dengan menjalankan perintah berikut:

kubectl cluster-info

Tugas 3. Menyiapkan Helm

Di lab ini, Anda akan menggunakan Helm untuk menginstal Jenkins dari repositori Chart. Helm adalah pengelola paket yang memudahkan konfigurasi dan deployment aplikasi Kubernetes. Setelah Jenkins diinstal, Anda dapat menyiapkan pipeline CI/CD.

1. Tambahkan repositori chart stabil Helm:

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

2. Pastikan repo selalu terbaru:

helm repo update

Tugas 4. Mengonfigurasi dan menginstal Jenkins

Saat menginstal Jenkins, file values dapat digunakan sebagai template untuk memberikan nilai yang diperlukan untuk penyiapan.

Anda akan menggunakan file values kustom untuk secara otomatis mengonfigurasi Kubernetes Cloud dan menambahkan plugin yang diperlukan berikut:

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

Ini akan memungkinkan Jenkins untuk terhubung ke cluster dan project GCP Anda.

1. Gunakan Helm CLI untuk men-deploy chart dengan setelan konfigurasi Anda:

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

Pemrosesan perintah ini dapat membutuhkan waktu beberapa menit.

Menguji tugas yang sudah selesai

Klik Check my progress untuk memverifikasi tugas yang telah diselesaikan. Jika chart Jenkins telah berhasil dikonfigurasi, Anda akan melihat skor penilaian.

Mengonfigurasi dan Menginstal Jenkins

2. Setelah pemrosesan perintah tersebut selesai, pastikan pod Jenkins beralih ke status Running dan container berada dalam status READY:

kubectl get pods

Contoh Output:

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

3. Konfigurasi akun layanan Jenkins agar dapat men-deploy ke cluster:

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

Anda akan menerima output berikut:

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

4. Jalankan perintah berikut untuk menyiapkan penerusan port ke UI Jenkins dari Cloud Shell:

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. Sekarang, pastikan Layanan Jenkins telah dibuat dengan benar:

kubectl get svc

Contoh Output:

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

Anda menggunakan Plugin Kubernetes sehingga node builder kami akan secara otomatis diluncurkan saat diperlukan jika master Jenkins memintanya. Setelah menyelesaikan tugasnya, node builder akan otomatis dinonaktifkan dan resource-nya akan ditambahkan kembali ke kumpulan resource cluster.

Perhatikan bahwa layanan ini mengekspos port 8080, dan 50000 untuk tiap pod yang sesuai dengan selector. Hal ini akan mengekspos UI web Jenkins dan port registrasi builder/agen di dalam cluster Kubernetes. Selain itu, layanan jenkins-ui diekspos menggunakan ClusterIP sehingga tidak dapat diakses dari luar cluster.

Tugas 5. Menghubungkan ke Jenkins

1. Chart Jenkins akan secara otomatis membuatkan sandi admin bagi Anda. Untuk mengambilnya, jalankan:

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

2. Untuk mengakses antarmuka pengguna Jenkins, klik tombol Web Preview di Cloud Shell, lalu klik Preview on port 8080:

3. Jika diminta, login dengan nama pengguna admin dan sandi yang dibuat secara otomatis.

Jenkins sekarang sudah selesai disiapkan di cluster Kubernetes Anda. Jenkins akan menggerakkan pipeline CI/CD otomatis Anda di bagian selanjutnya.

Tugas 6. Memahami Aplikasi

Anda akan men-deploy aplikasi contoh, gceme, di pipeline deployment berkelanjutan. Aplikasi ini ditulis dalam bahasa Go dan berada di direktori sample-app repo. Saat Anda menjalankan biner gceme di instance Compute Engine, aplikasi akan menampilkan metadata instance dalam kartu info.

Aplikasi meniru microservice dengan mendukung dua mode operasi.

• Di mode backend: gceme memproses port 8080 lalu mengembalikan metadata instance Compute Engine dalam format JSON.
• Di mode frontend: gceme membuat kueri ke layanan gceme backend dan merender JSON yang dihasilkan di antarmuka pengguna.

Tugas 7. Men-deploy Aplikasi

Anda akan men-deploy aplikasi ke dalam dua lingkungan yang berbeda:

• Produksi: Situs live yang diakses oleh pengguna Anda.
• Canary: Situs berkapasitas lebih kecil yang hanya menerima sebagian dari traffic pengguna Anda. Gunakan lingkungan ini untuk memvalidasi software dengan traffic live sebelum dirilis ke semua pengguna.

1. Di Google Cloud Shell, buka direktori aplikasi contoh:

cd sample-app

2. Buat namespace Kubernetes untuk mengisolasi deployment secara logis:

kubectl create ns production

3. Buat deployment produksi dan canary, serta layanan menggunakan perintah kubectl apply:

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

Menguji tugas yang sudah selesai

Klik Check my progress untuk memverifikasi tugas yang telah diselesaikan. Jika deployment berhasil dibuat, Anda akan melihat skor penilaian.

Membuat deployment produksi dan canary

Secara default, hanya satu replika frontend yang di-deploy. Gunakan perintah kubectl scale untuk memastikan setidaknya ada 4 replika yang selalu berjalan.

4. Tingkatkan skala frontend lingkungan produksi dengan menjalankan perintah berikut:

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

5. Selanjutnya, konfirmasi bahwa ada 5 pod yang berjalan untuk frontend, yaitu 4 pod untuk traffic produksi dan 1 pod untuk rilis terbatas (perubahan pada rilis terbatas hanya akan memengaruhi 1 dari 5 (20%) pengguna):

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

6. Konfirmasi pula bahwa Anda memiliki 2 pod untuk backend, yaitu 1 pod untuk produksi dan 1 pod untuk canary:

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

7. Ambil IP eksternal untuk layanan produksi:

kubectl get service gceme-frontend -n production Catatan: Perlu waktu beberapa menit sebelum Anda dapat melihat alamat IP eksternal load balancer.

Contoh Output:

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

Tempel External IP ke browser untuk melihat kartu info yang ditampilkan di kartu. Anda akan mendapatkan halaman serupa berikut:

8. Sekarang, simpan IP load balancer layanan frontend di suatu variabel lingkungan untuk digunakan nanti:

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

9. Konfirmasi bahwa kedua layanan dapat berfungsi dengan membuka alamat IP eksternal frontend di browser Anda.

10. Periksa output versi layanan dengan menjalankan perintah berikut (harus terbaca 1.0.0):

curl http://$FRONTEND_SERVICE_IP/version

Anda telah berhasil men-deploy aplikasi contoh. Selanjutnya, Anda akan menyiapkan pipeline untuk men-deploy perubahan Anda secara berkelanjutan dan andal.

Tugas 8. Membuat Pipeline Jenkins

Membuat repositori untuk menghosting kode sumber aplikasi contoh

1. Buat salinan aplikasi contoh gceme dan kirim ke Cloud Source Repository:

gcloud source repos create default

Anda dapat mengabaikan peringatan dan tidak akan dikenai biaya atas repositori ini.

Menguji tugas yang sudah selesai

Klik Check my progress untuk memverifikasi tugas yang telah diselesaikan. Jika repositori sumber berhasil dibuat, Anda akan melihat skor penilaian.

Membuat repositori git init

2. Lakukan inisialisasi direktori sample-app sebagai repositori Git miliknya sendiri:

git config credential.helper gcloud.sh

3. Jalankan perintah berikut:

git remote add origin https://source.developers.google.com/p/$DEVSHELL_PROJECT_ID/r/default

4. Tetapkan nama pengguna dan alamat email untuk commit Git Anda. Ganti [EMAIL_ADDRESS] dengan alamat email Git Anda dan [USERNAME] dengan nama pengguna Git Anda:

git config --global user.email "[EMAIL_ADDRESS]" git config --global user.name "[USERNAME]"

5. Tambahkan, commit, dan kirim file:

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

Menambahkan kredensial akun layanan Anda

Konfigurasikan kredensial Anda agar Jenkins dapat mengakses repositori kode. Jenkins akan menggunakan kredensial akun layanan cluster Anda untuk mendownload kode dari Cloud Source Repositories.

1. Di antarmuka pengguna Jenkins, klik Manage Jenkins di navigasi sebelah kiri, lalu klik Security > Credentials.

2. Klik System.

3. Klik Global credentials (unrestricted).

4. Klik Add Credentials di pojok kanan atas.

5. Pilih Google Service Account from metadata dari drop-down Kind, lalu klik Create.

Kredensial global telah ditambahkan. Nama kredensial adalah Project ID yang ditemukan di bagian CONNECTION DETAILS pada lab.

Mengonfigurasi Cloud Jenkins untuk Kubernetes

1. Di antarmuka pengguna Jenkins, pilih Manage Jenkins > Nodes.
2. Klik Clouds pada panel navigasi sebelah kiri.
3. Klik New cloud.
4. Ketik nama apa saja di bawah Cloud name, lalu pilih Kubernetes untuk Type.
5. Klik Create.
6. Klik Kubernetes Cloud Details.
7. Pada kolom Jenkins URL, masukkan nilai berikut: http://cd-jenkins:8080
8. Pada kolom Jenkins tunnel, masukkan nilai berikut: cd-jenkins-agent:50000
9. Klik Save.

Membuat tugas Jenkins

Buka antarmuka pengguna Jenkins Anda, lalu ikuti langkah-langkah ini untuk mengonfigurasi tugas Pipeline.

1. Klik Dashboard > New Item pada panel sebelah kiri.

2. Beri nama project sample-app, lalu pilih opsi Multibranch Pipeline dan klik OK.

3. Pada halaman berikutnya, di bagian Branch Sources, pilih Git dari drop-down Add Source.

4. Tempel HTTPS clone URL dari repositori sample-app di Cloud Source Repositories ke dalam kolom Project Repository. Ganti [PROJECT_ID] dengan Project ID Anda:

https://source.developers.google.com/p/[PROJECT_ID]/r/default

5. Dari drop-down Credentials, pilih nama kredensial yang Anda buat saat menambahkan akun layanan di langkah sebelumnya.

6. Di bagian Scan Multibranch Pipeline Triggers, centang kotak Periodically if not otherwise run, lalu tetapkan nilai Interval ke 1 minute.

7. Konfigurasi tugas Anda akan terlihat seperti ini:

8. Klik Save dan tetap gunakan nilai default untuk semua opsi lainnya.

Setelah Anda menyelesaikan langkah-langkah ini, tugas yang bernama Branch indexing akan berjalan. Tugas meta ini mengidentifikasi cabang di repositori Anda dan memastikan tidak terjadi perubahan di cabang yang ada. Jika Anda mengklik sample-app di kiri atas, tugas master akan terlihat.

Catatan: Tugas master pertama yang dijalankan mungkin akan terus gagal hingga Anda membuat beberapa perubahan kode di langkah berikutnya.

Anda telah berhasil membuat pipeline Jenkins! Selanjutnya, Anda akan membuat lingkungan pengembangan untuk continuous integration.

Tugas 9. Membuat lingkungan pengembangan

Cabang pengembangan adalah sekumpulan lingkungan yang digunakan oleh developer Anda untuk menguji perubahan kode sebelum mengirimkannya untuk diintegrasikan ke situs live. Lingkungan ini adalah versi kecil dari aplikasi Anda, tetapi perlu di-deploy menggunakan mekanisme yang sama dengan lingkungan aktif.

Membuat cabang pengembangan

Untuk membuat lingkungan pengembangan dari cabang fitur, Anda dapat mengirimkan cabang ke server Git dan membiarkan Jenkins men-deploy lingkungan.

• Buat cabang pengembangan, lalu kirimkan ke server Git:

git checkout -b new-feature

Mengubah definisi pipeline

Jenkinsfile yang mendefinisikan pipeline tersebut ditulis menggunakan sintaksis Jenkins Pipeline Groovy. Dengan menggunakan Jenkinsfile, seluruh pipeline build dapat diekspresikan dalam satu file yang aktif bersama kode sumber Anda. Pipeline mendukung fitur-fitur canggih, seperti paralelisasi, dan memerlukan persetujuan pengguna secara manual.

Agar pipeline dapat berfungsi seperti yang diharapkan, Anda harus memodifikasi Jenkinsfile untuk menetapkan ID project.

1. Buka Jenkinsfile di editor terminal, misalnya vi:

vi Jenkinsfile

2. Mulai editor:

i

3. Tambahkan PROJECT_ID ke nilai REPLACE_WITH_YOUR_PROJECT_ID. (PROJECT_ID Anda adalah Project ID yang ditemukan di bagian CONNECTION DETAILS pada lab. Anda juga dapat menjalankan gcloud config get-value project untuk menemukannya.

4. Ubah nilai CLUSTER_ZONE menjadi . Anda bisa mendapatkan nilai ini dengan menjalankan 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. Simpan file Jenkinsfile: tekan tombol Esc, lalu (untuk pengguna vi):

:wq

Memodifikasi situs

Untuk menunjukkan perubahan aplikasi, Anda akan mengubah warna kartu gceme dari biru menjadi oranye.

1. Buka html.go:

vi html.go

2. Mulai editor:

i

3. Ganti dua instance <div class="card blue"> dengan kode berikut:

<div class="card orange">

4. Simpan file html.go: tekan tombol Esc, lalu:

:wq

5. Buka main.go:

vi main.go

6. Mulai editor:

i

7. Versi ditentukan di baris ini:

const version string = "1.0.0"

Perbarui kode menjadi berikut:

const version string = "2.0.0"

8. Simpan file main.go sekali lagi: tekan tombol Esc, lalu:

:wq

Tugas 10. Mulai Deployment

1. Commit dan kirim perubahan Anda:

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

Tindakan ini akan memulai pembuatan lingkungan pengembangan Anda.

Setelah perubahan dikirimkan ke repositori Git, buka antarmuka pengguna Jenkins tempat Anda dapat melihat bahwa build untuk cabang new-feature telah dimulai. Diperlukan waktu hingga satu menit hingga perubahan mulai berlaku.

2. Setelah build berjalan, klik panah bawah di sebelah build di menu navigasi kiri, lalu pilih Console output:

3. Lacak output build selama beberapa menit dan perhatikan pesan kubectl --namespace=new-feature apply... akan mulai. Cabang new-feature sekarang akan di-deploy untuk cluster.

Catatan: Dalam skenario pengembangan, Anda tidak akan menggunakan load balancer yang ditampilkan kepada publik. Untuk membantu mengamankan aplikasi, Anda dapat menggunakan proxy kubectl. Proxy tersebut mengautentikasi dirinya sendiri dengan Kubernetes API dan menjalankan proxy permintaan dari mesin lokal Anda ke layanan di cluster tanpa mengekspos layanan Anda ke Internet.

Jika Anda tidak melihat apa pun di Build Executor, jangan khawatir. Cukup buka halaman beranda Jenkins > sample app. Pastikan bahwa pipeline new-feature telah dibuat.

4. Setelah semuanya diatasi, mulai proxy di latar belakang:

kubectl proxy &

5. Jika terhenti, tekan Ctrl + C untuk keluar. Verifikasi bahwa aplikasi Anda dapat diakses dengan mengirimkan permintaan ke localhost dan proxy kubectl akan meneruskannya ke layanan:

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

Anda akan melihatnya merespons dengan 2.0.0 yang merupakan versi yang berjalan sekarang.

Jika Anda menerima error serupa:

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

6. Ini berarti endpoint frontend Anda belum diterapkan. Tunggu sebentar, lalu coba kembali perintah curl. Lanjutkan jika Anda mendapatkan output berikut:

2.0.0

Anda telah menyiapkan lingkungan pengembangan. Selanjutnya, Anda akan mengembangkan hal yang telah dipelajari dalam modul sebelumnya dengan men-deploy rilis terbatas untuk menguji fitur baru.

Tugas 11. Men-deploy rilis terbatas

Anda telah memverifikasi bahwa aplikasi Anda menjalankan kode terbaru di lingkungan pengembangan. Selanjutnya, deploy kode tersebut ke lingkungan canary.

1. Buat cabang canary, lalu kirimkan ke server Git:

git checkout -b canary git push origin canary

2. Di Jenkins, Anda akan melihat bahwa pipeline canary telah dimulai. Setelah selesai, Anda dapat memeriksa URL layanan untuk memastikan bahwa sebagian dari traffic dilayani oleh versi yang baru. Anda akan melihat sekitar 1 dari 5 permintaan (tanpa urutan tertentu) menampilkan versi 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. Jika Anda tetap melihat versi 1.0.0, coba jalankan kembali perintah di atas. Setelah Anda memverifikasi bahwa cara di atas berfungsi dengan baik, akhiri perintah dengan Ctrl + C.

Selesai. Anda telah men-deploy rilis terbatas. Berikutnya, Anda akan men-deploy versi baru ke produksi.

Tugas 12. Men-deploy ke produksi

Setelah rilis terbatas berhasil dan belum ada pelanggan yang mengeluh, lakukan deployment ke seluruh fleet produksi Anda.

1. Buat cabang canary, lalu kirimkan ke server Git:

git checkout master git merge canary git push origin master

Di Jenkins, Anda akan melihat pipeline master telah dimulai.

2. Setelah selesai (yang mungkin memerlukan waktu beberapa menit), Anda dapat memeriksa URL layanan untuk memastikan bahwa semua traffic disalurkan oleh versi baru, 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. Sekali lagi, jika Anda melihat instance 1.0.0, coba jalankan kembali perintah di atas. Anda dapat menghentikan perintah ini dengan menekan Ctrl + C.

Contoh output:

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

Anda juga dapat membuka situs tempat aplikasi gceme menampilkan kartu info. Warna kartu berubah dari biru menjadi oranye.

4. Berikut adalah perintah untuk mendapatkan alamat IP eksternal. Tempel External IP ke tab baru untuk melihat kartu info yang ditampilkan.

kubectl get service gceme-frontend -n production

Contoh output:

Tugas 13. Menguji Pemahaman Anda

Di bawah ini terdapat beberapa pertanyaan pilihan ganda untuk memperkuat pemahaman Anda tentang konsep lab ini. Jawab pertanyaan tersebut sebaik mungkin.

Selesai!

Bagus, Anda telah berhasil men-deploy aplikasi ke produksi!

Selamat!

Bagian ini mengakhiri lab praktik tentang men-deploy dan menggunakan Jenkins di Kubernetes Engine untuk mengaktifkan pipeline Continuous Delivery/Deployment Berkelanjutan. Anda telah berkesempatan men-deploy fitur DevOps penting di Kubernetes Engine dan mengonfigurasikannya untuk penggunaan produksi. Anda telah mempelajari alat command line kubectl dan konfigurasi deployment dalam file YAML, serta telah belajar sedikit tentang penyiapan jaringan pipeline Jenkins untuk proses pengembangan/deployment. Berbekal pengalaman praktis ini, Anda diharapkan dapat dengan yakin menerapkan alat ini di lingkungan DevOps Anda sendiri.

Menyelesaikan Quest Anda

Lab mandiri ini merupakan bagian dari Quest Kubernetes in the Google Cloud, Cloud Architecture, dan DevOps Essentials. Quest adalah serangkaian lab terkait yang membentuk jalur pembelajaran. Dengan menyelesaikan Quest, Anda mendapatkan badge sebagai pengakuan atas pencapaian Anda. Anda dapat menunjukkan satu atau beberapa badge kepada orang lain secara publik dan menautkannya di resume online atau akun media sosial Anda. Daftarkan diri Anda dalam Quest apa pun yang berisi lab ini dan segera dapatkan kredit penyelesaian. Lihat Katalog Google Cloud Skills Boost untuk menemukan semua Quest yang tersedia.

Ikuti lab berikutnya

Lanjutkan Quest Anda dengan Memahami Node Kubernetes, atau lihat lab Google Cloud Skills Boost ini:

• Mengorkestrasi Cloud dengan Kubernetes
• Mengelola Deployment Menggunakan Kubernetes Engine

Langkah berikutnya/Pelajari lebih lanjut

• Baca selengkapnya di Solusi Jenkins di Kubernetes Engine
• Pelajari cara menggunakan Jenkins untuk mengaktifkan Continuous Delivery ke Kubernetes Engine
• Baca selengkapnya di Solusi DevOps dan Panduan DevOps di dokumentasi Google Cloud
• Bergabung dengan Komunitas Jenkins

Sertifikasi dan pelatihan Google Cloud

...membantu Anda mengoptimalkan teknologi Google Cloud. Kelas kami mencakup keterampilan teknis dan praktik terbaik untuk membantu Anda memahami dengan cepat dan melanjutkan proses pembelajaran. Kami menawarkan pelatihan tingkat dasar hingga lanjutan dengan opsi on demand, live, dan virtual untuk menyesuaikan dengan jadwal Anda yang sibuk. Sertifikasi membantu Anda memvalidasi dan membuktikan keterampilan serta keahlian Anda dalam teknologi Google Cloud.

Manual Terakhir Diperbarui pada 20 September 2023

Lab Terakhir Diuji pada 20 September 2022

Hak cipta 2024 Google LLC Semua hak dilindungi undang-undang. Google dan logo Google adalah merek dagang dari Google LLC. Semua nama perusahaan dan produk lain mungkin adalah merek dagang masing-masing perusahaan yang bersangkutan.