Jalur Pembelajaran: Mengubah monolith menjadi aplikasi GKE - Men-deploy aplikasi ke cluster GKE

Ini adalah tutorial kelima dan terakhir dalam jalur pembelajaran yang mengajarkan cara memodularisasi dan membuat container aplikasi monolitik.

Jalur pembelajaran terdiri dari tutorial berikut:

  1. Ringkasan
  2. Memahami monolith
  3. Modularisasi monolit
  4. Menyiapkan aplikasi modular untuk di-build dalam container
  5. Memasukkan aplikasi modular ke dalam container
  6. Men-deploy aplikasi ke cluster GKE (tutorial ini)

Dalam tutorial sebelumnya, Mengontainerkan aplikasi modular, Anda menyiapkan aplikasi Cymbal Books modular untuk deployment. Anda telah membuat modul aplikasi dalam container, menguji container yang dihasilkan, dan mengirim image container ke Artifact Registry.

Dalam tutorial ini, Anda akan men-deploy aplikasi dalam container ke cluster Google Kubernetes Engine. Langkah ini menyelesaikan transformasi aplikasi Cymbal Books menjadi sistem modular dan skalabel yang berjalan di cluster Kubernetes.

Biaya

Mengikuti langkah-langkah dalam tutorial ini akan menimbulkan biaya pada akun Google Cloud Anda. Biaya dimulai saat Anda mengaktifkan GKE dan men-deploy aplikasi contoh Cymbal Books. Biaya ini mencakup biaya per cluster untuk GKE, seperti yang diuraikan di halaman Harga, dan biaya untuk menjalankan VM Compute Engine.

Untuk menghindari biaya yang tidak perlu, pastikan Anda menonaktifkan GKE atau menghapus project setelah menyelesaikan tutorial ini.

Sebelum memulai

Sebelum memulai tutorial ini, pastikan Anda telah menyelesaikan tutorial sebelumnya dalam seri ini. Untuk mengetahui ringkasan seluruh seri, dan link ke tutorial tertentu, lihat Jalur Pembelajaran: Mengubah aplikasi monolitik menjadi aplikasi GKE - Ringkasan.

Secara khusus, Anda harus telah melakukan langkah-langkah dalam tutorial sebelumnya, yaitu Mengontainerkan aplikasi modular.

Menyiapkan cluster GKE

Sebelum dapat men-deploy aplikasi Cymbal Books modular, Anda harus membuat cluster GKE terlebih dahulu. Cluster ini menyediakan infrastruktur tempat container aplikasi Anda akan berjalan.

Dalam tutorial ini, Anda menggunakan gcloud CLI untuk membuat cluster. Atau, Anda dapat menggunakan konsolGoogle Cloud , yang menyediakan antarmuka pengguna grafis (GUI) untuk membuat dan mengelola Google Cloud resource seperti cluster GKE.

Membuat dan memverifikasi cluster GKE

Cluster GKE menyediakan resource komputasi yang diperlukan untuk menjalankan container Anda di Kubernetes. Ikuti langkah-langkah berikut untuk membuat cluster menggunakan gcloud CLI.

  1. Buka Google Cloud console.

  2. Di konsol, klik tombol Activate Cloud Shell: Mengaktifkan Cloud Shell

    Sesi Cloud Shell akan terbuka di dalam frame yang lebih rendah di konsol.

  3. Tetapkan project default Anda di Google Cloud CLI:

    gcloud config set project PROJECT_ID

    Ganti PROJECT_ID dengan project ID project yang Anda buat atau pilih di bagian pilih atau buat project Google Cloud pada tutorial sebelumnya. Project ID adalah string unik yang membedakan project Anda dari semua project lain di Google Cloud. Untuk menemukan project ID, buka pemilih project. Di halaman tersebut, Anda dapat melihat project ID untuk setiap project Google Cloud Anda.

  4. Buat cluster GKE:

    gcloud container clusters create CLUSTER_NAME \
    --zone=ZONE \
    --num-nodes=2

    Ganti kode berikut:

    • CLUSTER_NAME: nama untuk cluster Anda, seperti cymbal-cluster.

    • ZONE: zona tempat Anda ingin membuat cluster, seperti us-central1-a atau europe-west1-b. Untuk mengetahui daftar lengkap zona yang tersedia, lihat Region dan zona.

  5. Ambil kredensial cluster agar CLI kubectl dapat terhubung ke cluster:

    gcloud container clusters get-credentials CLUSTER_NAME \
    --zone=ZONE

    Perintah ini mengupdate file konfigurasi Kubernetes Anda, yang disimpan secara default di ~/.kube/config. File konfigurasi ini berisi kredensial yang diperlukan kubectl untuk berinteraksi dengan cluster GKE Anda.

  6. Pastikan kubectl terhubung ke cluster dengan mencantumkan node cluster:

    kubectl get nodes

    Jika penyiapan berhasil, perintah ini akan mencantumkan node di cluster GKE Anda. Karena Anda membuat cluster dengan --num-nodes=2, Anda akan melihat informasi tentang dua node, mirip dengan berikut:

    NAME                                         STATUS    ROLES    AGE    VERSION
gke-nov18-default-pool-6a8f9caf-bryg   Ready     <none>   30s    v1.30.8-gke.1128000
gke-nov18-default-pool-6a8f9caf-ut0i   Ready     <none>   30s    v1.30.8-gke.1128000

    Dalam contoh ini, kedua node berada dalam status Ready. Status ini berarti cluster GKE siap menghosting workload yang di-containerisasi.

Deploy aplikasi

Setelah membuat cluster GKE, Anda dapat men-deploy aplikasi Cymbal Books ke cluster tersebut. Untuk men-deploy aplikasi ke cluster, Anda menerapkan manifes Kubernetes ke cluster.

Terapkan manifes Kubernetes

Di Cloud Shell, deploy aplikasi ke cluster GKE dengan menjalankan perintah berikut:

  1. Buka direktori root aplikasi dalam container:

    cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/

  2. Terapkan manifes Kubernetes:

    kubectl apply -f kubernetes_manifest.yaml

Perintah sebelumnya menginstruksikan Kubernetes untuk membuat resource yang ditentukan dalam file kubernetes-manifest.yaml. Resource ini mencakup Layanan, Deployment, dan Pod.

Anda pertama kali menemukan Layanan di bagian Ubah kode modular dalam tutorial Siapkan aplikasi modular untuk penampungan. Dalam tutorial tersebut, Anda memperbarui kode aplikasi untuk menggunakan Nama layanan, bukan localhost. Pembaruan tersebut memungkinkan Kubernetes merutekan permintaan antar-modul dan memastikan bahwa modul dapat berkomunikasi satu sama lain dalam cluster. Sekarang, saat Anda menerapkan manifes, Kubernetes akan membuat Layanan di dalam cluster.

Deployment adalah objek Kubernetes API yang memungkinkan Anda menjalankan beberapa replika Pod yang didistribusikan di antara node dalam cluster. Bagian berikutnya menjelaskan apa itu Pod.

Apa yang dimaksud dengan Pod Kubernetes?

Dalam tutorial sebelumnya, Anda membuat image container untuk setiap modul aplikasi Cymbal Books. Misalnya, Anda membuat image container berdasarkan modul home_app dan book_details_app.

Saat Anda menggunakan perintah kubectl apply untuk men-deploy manifes Kubernetes, Kubernetes akan menarik image container Anda dari Artifact Registry ke dalam cluster. Di cluster, image container menjadi container, dan container berjalan di dalam Pod.

Pod adalah lingkungan terisolasi tempat container berjalan, dan melakukan tugas-tugas berikut:

  • Mengalokasikan CPU dan memori: Pod menyediakan resource yang dibutuhkan container untuk beroperasi.
  • Menyediakan jaringan: setiap Pod memiliki alamat IP-nya sendiri. Hal ini memungkinkan Pod berkomunikasi dengan Pod lain.

Pod berjalan di node, yang merupakan mesin yang menyediakan daya komputasi untuk cluster. Kubernetes secara otomatis menetapkan Pod ke node dan mendistribusikan Pod di seluruh node cluster untuk mengurangi risiko kelebihan beban pada satu node. Distribusi ini membantu cluster menggunakan resource komputasi dan memori secara efisien.

Memverifikasi Deployment

Setelah Anda menerapkan manifes Kubernetes dengan perintah kubectl apply, verifikasi bahwa aplikasi berhasil di-deploy ke cluster. Untuk memverifikasi Deployment, periksa apakah Pod dan Layanan berjalan dengan benar.

Periksa Pod

Untuk melihat Pod di cluster Anda, jalankan perintah berikut:

kubectl get pods

Perintah ini mencantumkan Pod dan statusnya saat ini. Cari kolom STATUS untuk mengonfirmasi bahwa semua Pod ditandai sebagai Running, yang menunjukkan bahwa Pod tersebut berhasil berjalan dan siap melayani permintaan. Output yang diharapkan akan terlihat seperti berikut:

NAME                             READY   STATUS    RESTARTS   AGE
home-app-67d59c6b6d-abcde        1/1     Running   0          30s
book-details-app-6d8bcbc58f-xyz  1/1     Running   0          30s
book-reviews-app-75db4c4d7f-def  1/1     Running   0          30s
images-app-7f8c75c79c-ghi        1/1     Running   0          30s

Status Pod awalnya muncul sebagai Pending saat dibuat dan container-nya sedang dalam proses dimulai. Jika Pod tetap Pending selama jangka waktu yang lama, cluster mungkin tidak memiliki cukup resource agar Pod tersebut dapat memasuki status Running yang sehat. Jika Pod memiliki status CrashLoopBackOff, mungkin ada masalah dengan container. Langkah-langkah pemecahan masalah akan diberikan di bagian selanjutnya dalam tutorial ini.

Periksa Layanan

Layanan memungkinkan komunikasi antar-Pod dan memungkinkan klien eksternal (misalnya, pengguna, skrip otomatis, atau alat pemantauan) mengakses aplikasi. Untuk melihat Layanan di cluster Anda, jalankan perintah berikut:

kubectl get services

Output dari perintah ini akan terlihat seperti berikut:

NAME               TYPE           CLUSTER-IP      EXTERNAL-IP       PORT(S)        AGE
home-app-service   LoadBalancer   10.12.3.4       35.185.1.2        80:30837/TCP   30s
details-service    ClusterIP      10.12.3.5       <none>            80/TCP         30s
reviews-service    ClusterIP      10.12.3.6       <none>            80/TCP         30s
images-service     LoadBalancer   10.12.3.7       34.125.6.3        80:32014/TCP   30s

Kolom utama yang perlu diamati dalam output adalah sebagai berikut:

  • TYPE: kolom ini menunjukkan cara Layanan diekspos. Layanan jenis LoadBalancer menyediakan akses eksternal ke aplikasi.
  • EXTERNAL-IP: untuk Layanan berjenis LoadBalancer, kolom EXTERNAL-IP menampilkan alamat IP publik yang dapat dimasukkan pengguna ke browser web mereka untuk mengakses aplikasi. Untuk Layanan berjenis ClusterIP, kolom ini kosong karena Layanan ClusterIP hanya dapat diakses dalam cluster.

Melakukan pengujian deployment

Setelah men-deploy aplikasi Cymbal Books ke cluster GKE, verifikasi bahwa aplikasi dapat diakses dan bahwa container dapat berkomunikasi satu sama lain.

Mengakses aplikasi

Pastikan aplikasi dapat diakses dengan mengikuti langkah-langkah berikut:

  1. Ambil alamat IP eksternal untuk home-app-service:

    kubectl get services

    Cari kolom **EXTERNAL-IP** di output, dan catat alamat IP yang terkait dengan home-app-service.

  2. Buka browser web dan masukkan URL berikut:

    http://EXTERNAL-IP

    Ganti EXTERNAL-IP dengan alamat IP yang Anda temukan di langkah sebelumnya.

  3. Pastikan halaman beranda aplikasi Cymbal Books dimuat dengan benar.

Memverifikasi komunikasi antarlayanan

Kontainer di aplikasi Cymbal Books mengandalkan Layanan untuk bertukar informasi. Pastikan bahwa penampung dapat berkomunikasi secara efektif dengan mengikuti langkah-langkah berikut:

  1. Ambil alamat IP eksternal untuk home-app-service seperti yang dijelaskan sebelumnya.

  2. Gunakan antarmuka aplikasi untuk menguji interaksi antar-penampung. Untuk melakukannya, pastikan fitur berikut berfungsi dengan mengklik semua link yang tersedia di antarmuka aplikasi:

    • Periksa gambar sampul buku: pastikan gambar sampul buku dimuat dengan benar di halaman beranda dan halaman detail buku. Jika ya, container home_app dan book_details_app berhasil berkomunikasi dengan container images_app.
    • Melihat detail buku: membuka halaman detail buku dari halaman beranda. Jika Anda melihat detail buku, penampung home_app berkomunikasi dengan benar dengan book_details_app.
    • Melihat ulasan buku: klik link ulasan buku untuk memverifikasi bahwa penampung home_app dapat berkomunikasi dengan penampung book_reviews_app.

Aplikasi Anda kini berjalan di cluster GKE.

Selamat! Anda telah melihat cara mengubah aplikasi monolitik menjadi sistem modular berbasis container yang berjalan di cluster GKE aktif. Selama prosesnya, Anda telah mempelajari cara membagi kode yang terhubung erat menjadi modul independen, membangun dan mengirim image container ke repositori, menentukan manifes Kubernetes, dan men-deploy aplikasi dari registry ke GKE. Ini adalah pencapaian besar, dan mencerminkan langkah-langkah nyata yang dilakukan tim untuk memodernisasi aplikasi untuk cloud.

Pemecahan masalah

Jika aplikasi tidak merespons atau penampung gagal berkomunikasi, gunakan langkah-langkah pemecahan masalah berikut untuk mendiagnosis dan menyelesaikan masalah umum.

Memeriksa status Pod

Mulai dengan mencantumkan semua Pod di cluster Anda untuk menentukan apakah Pod berjalan seperti yang diharapkan:

kubectl get pods

Tinjau output untuk mengonfirmasi bahwa setiap Pod dalam status Running. Jika ada Pod yang tidak berjalan, catat namanya untuk pemeriksaan lebih lanjut.

Memeriksa log Pod

Jika Pod tidak menangani permintaan dengan benar, periksa lognya untuk mencari pesan error:

kubectl logs POD_NAME

Ganti POD_NAME dengan nama Pod yang ingin Anda periksa. Perintah ini berguna untuk mengidentifikasi masalah startup atau error runtime.

Mendeskripsikan Pod untuk mendapatkan informasi mendetail

Jika Pod tetap dalam status non-Running selama lebih dari lima menit—misalnya, Pod dalam status Pending, ContainerCreating, atau CrashLoopBackOff—Anda dapat melihat informasi mendetail tentang status dan peristiwa Pod menggunakan perintah berikut:

kubectl describe pod POD_NAME

Ganti POD_NAME dengan nama Pod yang ingin Anda ketahui informasi detailnya.

Bagian Events dalam output mungkin menunjukkan bahwa batasan resource atau masalah dengan penarikan image mencegah Pod dimulai dengan benar.

Verifikasi konfigurasi Layanan

Pastikan Layanan Anda disiapkan dengan benar, terutama Layanan yang mengekspos modul rumah dengan alamat IP eksternal. Cantumkan Layanan dengan perintah berikut:

kubectl get services

Jika Anda melihat bahwa modul Service for the home memiliki alamat EXTERNAL-IP yang tercantum sebagai Pending, jalankan perintah berikut:

kubectl describe service SERVICE_NAME

Ganti SERVICE_NAME dengan nama Service modul smart home.

Perintah ini memberikan detail selengkapnya tentang konfigurasi Layanan dan membantu Anda mengidentifikasi keterlambatan dalam menetapkan alamat IP eksternal atau masalah konfigurasi lainnya.

Memeriksa peristiwa cluster

Anda dapat memeriksa peristiwa cluster untuk menentukan apakah masalah memengaruhi beberapa komponen cluster Anda:

kubectl get events

Perintah ini dapat menentukan apakah masalah jaringan atau resource yang lebih luas memengaruhi deployment Anda.

Membersihkan resource

Menjalankan cluster GKE akan menimbulkan biaya. Setelah menyelesaikan tutorial ini, hapus resource Anda untuk menghindari biaya tambahan. Ikuti langkah-langkah berikut untuk menghapus cluster dan, secara opsional, seluruh project.

Menghapus cluster GKE

Untuk menghapus cluster GKE, gunakan perintah berikut:

gcloud container clusters delete CLUSTER_NAME
    --zone=ZONE

Ganti kode berikut:

  • CLUSTER_NAME: nama cluster yang Anda buat, seperti cymbal-cluster.

  • ZONE: zona tempat cluster dibuat, seperti us-central1-a.

Saat diminta, konfirmasi penghapusan.

Pastikan cluster telah dihapus

Untuk memastikan bahwa cluster telah dihapus, jalankan perintah berikut:

gcloud container clusters list

Cluster tidak akan muncul lagi di output. Jika ya, tunggu beberapa saat dan coba lagi.

(Opsional) Menghapus Google Cloud project

Jika Anda membuat Google Cloud project khusus untuk tutorial ini dan tidak memerlukannya lagi, Anda dapat menghapus seluruh Google Cloud project. Menghapus project akan menghapus semua resource dan menghentikan penagihan untuk project tersebut:

  1. Di Google Cloud console, buka halaman Manage Resources.
  2. Pilih project yang ingin Anda hapus.
  3. Klik Hapus Project dan ikuti perintah untuk mengonfirmasi.

Ringkasan seri

Selamat! Dengan menyelesaikan jalur pembelajaran ini, Anda telah mempelajari dasar-dasar mengonversi aplikasi monolitik menjadi aplikasi modular dalam container yang berjalan di cluster Kubernetes. Langkah-langkah berikut merangkum prosesnya:

  1. Memahami monolith

    • Mempelajari struktur aplikasi monolitik Cymbal Books.
    • Menyiapkan lingkungan Python lokal untuk menjalankan monolith dan menguji endpoint-nya.
    • Memperoleh pemahaman tentang codebase aplikasi untuk mempersiapkannya modularisasi.

  2. Modularisasi monolit

    • Mempelajari cara membagi kode monolitik menjadi modul terpisah. Setiap modul menangani fitur yang berbeda, seperti menampilkan detail atau ulasan buku.
    • Melihat cara modul ini diimplementasikan sebagai aplikasi Flask independen yang berjalan di port yang berbeda.
    • Menguji aplikasi yang dimodularisasi.

  3. Menyiapkan kode modular untuk containerisasi

    • Mempelajari bahwa Anda harus memperbarui URL di home.py untuk menggunakan nama Layanan, bukan localhost.
    • Mempelajari cara manifes Kubernetes menentukan Layanan yang memungkinkan modul aplikasi, yang sudah saling berkomunikasi, untuk saling menemukan dalam konteks cluster Kubernetes.

  4. Memasukkan aplikasi modular ke dalam container

    • Menyiapkan project Google Cloud dan meng-clone aplikasi dari GitHub ke Cloud Shell.
    • Membangun image container untuk setiap modul menggunakan Docker dan menguji container secara lokal.
    • Mengirim image container ke Artifact Registry untuk menyiapkan aplikasi agar di-deploy ke cluster.
    • Memperbarui manifes Kubernetes untuk merujuk ke jalur image container di Artifact Registry.

  5. Deploy aplikasi ke cluster GKE (tutorial yang sedang Anda ikuti):

    • Membuat cluster GKE.
    • Men-deploy image container dari Artifact Registry ke cluster GKE.
    • Menguji versi final aplikasi, yang kini dapat diskalakan dan berjalan di lingkungan Kubernetes.

Langkah berikutnya

Untuk pelatihan praktis lebih lanjut tentang cara membuat cluster, lihat seri kami, Jalur Pembelajaran: Aplikasi yang dapat diskalakan.