Jalur Pembelajaran: Mengubah monolith menjadi aplikasi GKE - Menyiapkan aplikasi modular untuk containerisasi

Ini adalah tutorial ketiga dalam jalur pembelajaran yang mengajarkan Anda cara memodulasi dan membuat aplikasi monolitik dalam penampung.

Jalur pembelajaran terdiri dari tutorial berikut:

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

Dalam tutorial sebelumnya, Membuat monolit menjadi modular, Anda telah melihat cara memisahkan aplikasi Cymbal Books menjadi modul Flask independen. Dalam tutorial ini, Anda akan mempelajari satu perubahan yang perlu dilakukan pada aplikasi modular untuk menyiapkannya untuk penampungan.

Biaya

Anda dapat menyelesaikan tutorial ini tanpa dikenai biaya apa pun. Namun, mengikuti langkah-langkah dalam tutorial terakhir dalam seri ini akan menimbulkan biaya pada akunGoogle Cloud Anda. Biaya dimulai saat Anda mengaktifkan GKE dan men-deploy aplikasi Cymbal Books ke cluster GKE. 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.

Jika Anda sudah menyelesaikan tutorial pertama, Anda telah meng-clone repositori GitHub. Ketiga versi aplikasi Cymbal Books berada di repositori tersebut, di dalam folder berikut:

  • monolith/
  • modular/
  • containerized/

Pastikan folder ini ada di komputer Anda sebelum melanjutkan.

Mengubah kode modular

Dalam tutorial sebelumnya, Anda telah mempelajari bahwa modul beranda berkomunikasi dengan modul lainnya. Modul ini mengirim permintaan ke endpoint modul lain untuk mengambil detail buku, ulasan, dan gambar, lalu menampilkan data ini di halaman HTML.

Di folder modular/, endpoint dikodekan secara permanen di home.py, menggunakan localhost, seperti ini:

BOOK_SERVICE_URL = "http://localhost:8081"     # Book details module listens on port 8081
REVIEW_SERVICE_URL = "http://localhost:8082"   # Book reviews module listens on port 8082
IMAGE_SERVICE_URL = "http://localhost:8083"    # Image module listens on port 8083

URL ini berfungsi saat semua modul berjalan di mesin yang sama. Namun, dalam lingkungan Kubernetes, modul dapat dipindahkan ke mesin yang berbeda untuk menangani kegagalan atau menyeimbangkan beban, yang berarti alamat IP-nya dapat berubah.

Untuk memastikan modul halaman beranda tetap dapat menjangkau modul lainnya, URL harus menggunakan nama Layanan Kubernetes, bukan localhost. Nama Layanan bertindak seperti alias yang digunakan Kubernetes untuk merutekan permintaan ke modul yang benar—di mana pun modul tersebut berjalan. Misalnya, saat modul halaman beranda mengirim permintaan ke http://book-details-service/book/1, Kubernetes memastikan bahwa permintaan tersebut mencapai modul book-details.

Anda tidak perlu memperbarui URL ini sendiri. Versi aplikasi di folder containerized/ sudah menyertakan perubahan ini: URL localhost yang di-hardcode telah diganti dengan nama Layanan Kubernetes. Anda dapat melihat versi yang diperbarui di containerized/home_app/home_app.py:

BOOK_SERVICE_URL = "http://book-details-service"
REVIEW_SERVICE_URL = "http://book-reviews-service"
IMAGE_SERVICE_URL = "http://images-service"

Update ini memastikan aplikasi akan berfungsi dengan benar saat dijalankan di lingkungan Kubernetes.

Manifes Kubernetes

Di bagian sebelumnya, Anda melihat cara endpoint modul diperbarui untuk menggunakan nama Layanan Kubernetes. Anda menentukan nama Layanan di manifes Kubernetes.

Manifest Kubernetes adalah file konfigurasi yang menentukan jenis cluster Kubernetes yang ingin Anda buat untuk menghosting aplikasi modular Anda. Manifest ditulis dalam YAML atau JSON. Di dalamnya, Anda menentukan hal-hal seperti Layanan (untuk merutekan antar-modul), jumlah replika (instance) setiap modul, dan jumlah CPU dan memori yang boleh digunakan setiap modul.

Seluruh seri tutorial dapat ditulis tentang manifes Kubernetes. Manifesnya rumit karena menentukan segala sesuatu tentang cluster Kubernetes Anda—struktur, perilaku, dan kemampuannya. Dalam tutorial ini, Anda hanya melihat cara nama Layanan dalam manifes cocok dengan nama yang digunakan di endpoint modul. Dalam tutorial berikutnya, Anda akan menjalankan perintah kubectl apply untuk membuat cluster GKE sesuai dengan konfigurasi yang ditentukan dalam manifes, tetapi dalam tutorial ini, Anda hanya meninjau manifes.

Melihat manifes

Di bagian ini, Anda akan memeriksa cara Layanan ditentukan dalam manifes Kubernetes yang telah ditulis untuk Anda. File manifes, yang merupakan file YAML, ada di folder containerized/ repositori GitHub yang Anda clone dalam tutorial pertama dari seri ini. Ikuti langkah-langkah berikut untuk melihat definisi Layanan:

  1. Di terminal, buka direktori yang di-container di repositori yang di-clone:

    cd containerized

  2. Di editor teks, buka file manifes Kubernetes:

    cat kubernetes_manifest.yaml

  3. Temukan definisi Layanan untuk modul book-details. Tampilannya akan terlihat seperti contoh berikut:

    apiVersion: v1
kind: Service
metadata:
name: book-details-service
spec:
selector:
    app: book-details-app
ports:
    - protocol: TCP
    port: 80  # External traffic on port 80
    targetPort: 8080  # Targeting container port 8080
type: ClusterIP

Nama Layanan book-details-service dalam manifes cocok dengan nama yang digunakan di endpoint modul: http://book-details-service. Saat aplikasi Anda berjalan di Kubernetes, Kubernetes menggunakan nama Layanan ini untuk merutekan permintaan ke modul yang benar.

Manifes Kubernetes menentukan fitur cluster Kubernetes Anda, termasuk Layanan yang menangani perutean permintaan. Setiap modul di aplikasi Anda memiliki Layanan terkait yang ditentukan dalam manifes. Dengan memperbarui URL dalam kode modular agar cocok dengan nama Layanan ini, Anda memastikan bahwa Kubernetes dapat merutekan permintaan ke modul yang benar saat aplikasi berjalan di cluster.

Ringkasan

Dalam tutorial ini, Anda telah melihat cara URL dalam kode modular diperbarui untuk menggunakan nama Layanan Kubernetes, seperti http://book-details-service. Nama Service ini memungkinkan Kubernetes merutekan permintaan antar-modul meskipun lokasinya dalam cluster berubah. Anda juga telah memeriksa manifes Kubernetes dan melihat cara nama Layanan dalam kode modular cocok dengan nama yang ditentukan dalam manifes.

Langkah berikutnya

Dalam tutorial berikutnya, Membuat aplikasi modular dalam container, Anda akan mempelajari cara membuat modul dalam container dengan mengemasnya ke dalam sesuatu yang disebut image container. Kemudian, Anda akan melihat cara menjalankan image container sebagai container, menguji fiturnya, dan mengirim image container ke Artifact Registry Google.