Jalur Pembelajaran: Mengubah monolith menjadi aplikasi GKE - Membuat monolith menjadi modular

Ini adalah tutorial kedua dalam jalur pembelajaran yang mengajarkan Anda cara membuat modular dan mengemas aplikasi monolitik ke dalam container.

Jalur pembelajaran terdiri dari tutorial berikut:

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

Dalam tutorial sebelumnya, Memahami monolit, Anda telah mempelajari aplikasi monolitik bernama Cymbal Books. Anda menjalankan monolith di mesin lokal dan mengetahui bahwa berbagai bagian monolith berkomunikasi satu sama lain melalui endpoint-nya.

Dalam tutorial ini, Anda akan melihat cara membagi monolit menjadi modul untuk mempersiapkannya bagi containerisasi. Anda tidak perlu melakukan langkah-langkah modularisasi sendiri karena kode telah diupdate untuk Anda. Tugas Anda adalah mengikuti tutorial dan menjelajahi aplikasi versi modular di repositori untuk melihat perbedaannya dengan monolit asli.

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 pertama, Memahami monolith. Dalam tutorial ini, Anda menjalankan versi modular Cymbal Books di komputer lokal. Untuk melakukannya, Anda harus menyiapkan lingkungan Anda terlebih dahulu. 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. Selain itu, pastikan lingkungan virtual book-review-env aktif. Jika Anda memerlukan pengingat tentang cara mengaktifkannya, lihat Membuat dan mengaktifkan lingkungan virtual dari tutorial pertama. Mengaktifkan lingkungan memastikan bahwa aplikasi versi modular memiliki semua yang diperlukan untuk berjalan.

Apa yang dimaksud dengan modularisasi?

Dalam tutorial ini, Anda akan mempelajari cara memodularisasi aplikasi monolitik untuk mempersiapkannya untuk containerisasi. Modularisasi adalah proses mengubah monolit menjadi aplikasi modular. Seperti yang telah Anda pelajari dalam tutorial sebelumnya, karakteristik pembeda monolit adalah komponennya tidak dapat berjalan atau menskalakan secara independen. Aplikasi modular berbeda: fungsinya dibagi menjadi modul yang dapat berjalan dan diskalakan secara independen.

Meskipun modularisasi dan penampungan sering dilakukan bersamaan, keduanya diperlakukan sebagai langkah terpisah dalam rangkaian tutorial ini untuk membantu Anda memahami setiap konsep dengan jelas. Tutorial ini menjelaskan cara memodulasi monolit, dan tutorial berikutnya menjelaskan cara membuat container aplikasi modular.

Modularisasi inkremental

Di lingkungan produksi, Anda biasanya memodularisasi satu komponen dalam satu waktu. Anda memodularisasi komponen, mengintegrasikan modul dengan monolit, dan memastikan semuanya berfungsi sebelum Anda mengerjakan komponen berikutnya. Status hybrid ini, di mana beberapa komponen dimodularisasi sementara yang lain tetap menjadi bagian dari monolit, disebut mikrolit. Namun, dalam tutorial ini, semua komponen aplikasi dimodularisasi secara bersamaan untuk memberikan contoh lengkap tentang cara memodularisasi aplikasi.

Cara memodularisasi monolith

Di bagian ini, Anda akan mempelajari cara memecah monolit Cymbal Books menjadi modul terpisah. Langkah-langkah disediakan untuk membantu Anda memahami proses modularisasi sehingga Anda dapat menerapkannya ke aplikasi Anda sendiri. Namun, Anda tidak perlu melakukan langkah-langkah ini dalam tutorial ini karena repositori yang di-clone sudah menyertakan aplikasi versi modular:

  1. Identifikasi fungsi berbeda dari aplikasi
  2. Membuat modul
  3. Mengaktifkan komunikasi antar-modul
  4. Memberi setiap modul akses hanya ke data yang dibutuhkannya

Mengidentifikasi fungsi berbeda dari aplikasi

Langkah pertama dalam memodularisasi monolit Cymbal Books adalah mengidentifikasi fungsi utamanya. Dalam aplikasi contoh Cymbal Books, monolith memiliki empat fungsi berbeda berikut:

  • Menayangkan halaman beranda
  • Menyajikan detail buku
  • Menyajikan ulasan buku
  • Menyajikan gambar sampul buku

Membuat modul

Seperti yang Anda lihat dalam tutorial sebelumnya, monolith adalah satu aplikasi Flask yang mengimplementasikan empat fungsi, yang diidentifikasi di bagian sebelumnya, sebagai pengendali rute. Untuk memodularisasi aplikasi, Anda mengambil setiap pengendali rute dan menempatkannya ke dalam aplikasi Flask-nya sendiri. Alih-alih satu aplikasi Flask dengan empat pengendali rute, Anda memiliki empat aplikasi Flask, yang masing-masing memiliki satu pengendali rute di dalamnya.

Diagram berikut mengilustrasikan transformasi ini dari satu aplikasi Flask menjadi empat aplikasi Flask terpisah:

Transformasi monolit menjadi aplikasi modular

Di aplikasi modular, setiap aplikasi Flask berjalan secara independen dan memproses port yang berbeda (8080, 8081, 8082, 8083), seperti yang ditunjukkan dalam diagram. Penyiapan ini diperlukan karena, saat Anda menguji aplikasi modular nanti dalam tutorial ini, Anda akan menjalankan semua modul di mesin yang sama. Setiap aplikasi memerlukan nomor port yang berbeda untuk menghindari konflik.

Modul halaman beranda memiliki dua tanggung jawab: melayani halaman beranda dan berkomunikasi dengan modul lain untuk mengumpulkan data yang perlu ditampilkan di halaman web. Setiap modul lainnya berfokus pada satu fungsi: menyajikan ulasan, detail, atau gambar. Modul ini tidak berkomunikasi satu sama lain, tetapi hanya merespons permintaan dari modul halaman beranda.

Meskipun modul halaman beranda memiliki peran koordinasi tambahan, aplikasi tetap benar-benar modular karena Anda dapat memperbarui modul apa pun tanpa memengaruhi modul lainnya. Aplikasi Flask besar tunggal telah dipecah menjadi empat bagian, yang masing-masing menangani bagian tertentu dari fungsi aplikasi.

Mengaktifkan komunikasi antar-modul

Setelah membuat modul, langkah selanjutnya adalah memastikan bahwa modul tersebut dapat berkomunikasi satu sama lain. Di aplikasi Cymbal Books, logika komunikasi ini sudah diterapkan untuk Anda. Di folder modular/ kode yang Anda download, Anda dapat melihat bahwa setiap fitur utama aplikasi —menayangkan halaman beranda, detail buku, ulasan, dan gambar—diimplementasikan sebagai aplikasi Flask terpisah. Setiap aplikasi ini menentukan endpoint HTTP-nya sendiri, dan modul berkomunikasi dengan mengirim permintaan HTTP ke endpoint tersebut.

Membuat monolit Cymbal Books menjadi modular cukup mudah. Monolit memiliki komponen yang ditentukan dengan baik yang diimplementasikan sebagai pengendali rute, dan setiap pengendali rute memiliki endpoint yang ditentukan dengan baik. Saat ditempatkan ke dalam aplikasi Flask terpisah, handler rute ini tetap dapat berkomunikasi melalui endpoint-nya. Tindakan mudah menempatkan pengendali rute ke dalam aplikasi Flask terpisah akan membuat modul dan memungkinkan modul berkomunikasi satu sama lain.

Pendekatan umum untuk komunikasi antar-modul adalah dengan menerapkan REST API, yang memungkinkan modul mengirim permintaan HTTP satu sama lain. Begitulah cara kerjanya di Cymbal Books: setiap modul menentukan endpoint REST menggunakan alat bawaan Flask. Pendekatan populer lainnya adalah gRPC, yang memungkinkan modul memanggil fungsi masing-masing secara langsung.

Alasan komunikasi mudah dilakukan di Cymbal Books

Setiap modul dalam aplikasi modular adalah aplikasi Flask terpisah yang berjalan di dalam server web. Misalnya, modul beranda menayangkan beranda, modul detail buku menayangkan detail buku. Komunikasi antar-modul sangat mudah karena server web dirancang untuk menangani permintaan dan respons HTTP. Setiap modul mengekspos endpoint yang dapat digunakan modul lain untuk meminta data.

Memberi setiap modul akses ke data yang diperlukan saja

Untuk memodularisasi monolit dengan benar, Anda harus memastikan bahwa setiap modul hanya memiliki akses ke data yang dibutuhkannya. Prinsip ini, yang dikenal sebagai isolasi data, adalah elemen penting dalam menciptakan arsitektur yang benar-benar modular.

Kesalahan umum yang dilakukan orang selama modularisasi adalah mengizinkan beberapa modul mengakses data yang sama, seperti satu database. Jenis penerapan ini menimbulkan masalah seperti berikut:

  • Keterikatan erat: jika struktur data bersama berubah—misalnya, tabel database diganti namanya atau kolom ditambahkan—setiap modul yang mengandalkan data tersebut harus diperbarui. Modularisasi yang tepat akan menghindari masalah ini.
  • Masalah toleransi kesalahan: jika beberapa modul menggunakan sumber data yang sama, kegagalan runtime di satu modul—seperti kueri yang tidak valid atau traffic yang berlebihan—dapat mengganggu modul lain. Kegagalan di satu bagian sistem dapat berlanjut menjadi kegagalan di bagian sistem lainnya.
  • Bottleneck performa: satu sumber data bersama dapat menjadi bottleneck, yang berarti dapat memperlambat seluruh aplikasi saat beberapa modul mencoba berinteraksi dengannya.

Untuk menghindari masalah ini, setiap modul harus memiliki sumber datanya sendiri.

Jika Cymbal Books menggunakan database untuk menyimpan datanya, Anda harus mereplikasi atau memartisi database untuk menerapkan isolasi data dan memastikan bahwa setiap modul hanya mengakses data yang dibutuhkannya. Replikasi melibatkan pemeliharaan salinan database terpisah untuk setiap modul, sementara partisi membatasi akses ke tabel atau baris tertentu. Kedua pendekatan mencegah modul mengganggu data satu sama lain.

Diagram berikut membandingkan arsitektur aplikasi buku monolitik dengan arsitektur modular aplikasi buku:

Diagram yang menunjukkan cara versi monolitik dan modular aplikasi menangani data

Implementasi monolit tidak mengikuti prinsip isolasi data karena fungsi monolit mengakses satu direktori data/.

Sebaliknya, aplikasi modular mencapai tingkat isolasi data tertentu dengan membagi data ke dalam direktori terpisah, dan memastikan bahwa setiap modul hanya berinteraksi dengan data yang ditetapkan untuknya:

  • Modul detail buku hanya mendapatkan data dari direktori details_data/.
  • Modul ulasan buku hanya mendapatkan data dari direktori reviews_data/.
  • Modul gambar hanya mendapatkan data dari direktori images/.

Dalam tutorial berikutnya, Anda akan melihat cara mengontainerisasi aplikasi untuk lebih meningkatkan isolasi data.

Yang baru saja Anda lihat

Dalam industri pengembangan software, Anda sering kali menemukan istilah microservice dan sistem terdistribusi. Bagian ini menjelaskan hubungan antara istilah-istilah ini dengan penerapan modular Cymbal Books.

Microservice

Microservice adalah modul otonom yang melakukan tugas tertentu. Modul ini berkomunikasi dengan modul lain melalui antarmuka seperti endpoint.

Setiap modul dalam versi modular Cymbal Books sesuai dengan definisi ini, dan oleh karena itu dapat disebut sebagai microservice. Saat aplikasi modular di-container dalam tutorial berikutnya, kode yang berjalan di dalam container juga dapat disebut sebagai microservice karena kode tersebut sama dengan kode yang berjalan di dalam modul.

Sistem terdistribusi

Sistem terdistribusi terdiri dari modul independen yang berkomunikasi melalui jaringan untuk mencapai tujuan bersama. Modul ini dapat berjalan di mesin yang berbeda, tetapi bekerja sama sebagai satu sistem.

Aplikasi Cymbal Books modular juga sesuai dengan definisi ini: modulnya berjalan secara independen dan bertukar data melalui HTTP, tetapi secara bersama-sama berfungsi sebagai satu sistem. Di bagian berikutnya, Anda akan menjalankan semua modul di satu mesin agar lebih sederhana, tetapi hal ini tidak wajib. Setiap modul dapat berjalan dengan mudah di server yang berbeda, itulah sebabnya versi modular aplikasi Cymbal Books dapat diklasifikasikan sebagai sistem terdistribusi.

Menguji penerapan modular

Setelah melihat cara transformasi monolit Cymbal Books menjadi aplikasi modular yang modulnya adalah aplikasi Flask, Anda dapat menguji aplikasi dan melihat bahwa setiap modul berjalan secara independen.

Dalam tutorial ini, Anda akan menjalankan modul di mesin yang sama. Namun, Anda juga dapat menjalankan setiap modul di server terpisah: karena setiap modul bersifat otonom, modul tersebut dapat berkomunikasi dengan modul lain melalui endpoint-nya.

Menyiapkan lingkungan Anda

Ikuti langkah-langkah berikut untuk bersiap melakukan pengujian:

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

    cd modular

  2. Pastikan lingkungan virtual book-review-env aktif. Jika Anda memerlukan pengingat tentang langkah-langkah aktivasi, lihat Membuat dan mengaktifkan lingkungan virtual.

Mulai aplikasi Flask

Folder /modular berisi skrip bash yang memulai semua aplikasi Flask secara bersamaan. Setiap modul aplikasi memproses di port unik seperti 8080 atau 8081:

  • Aplikasi Flask halaman beranda (home.py): port 8080
  • Aplikasi Flask detail buku (book_details.py): port 8081
  • Aplikasi Flask ulasan buku (book_reviews.py): port 8082
  • Aplikasi Flask Gambar (images.py): port 8083

Setiap modul harus memproses nomor port yang unik karena semua modul berjalan di mesin yang sama. Jika setiap modul berada di server yang berbeda, setiap modul dapat memproses di nomor port yang sama tanpa menimbulkan konflik port.

Jalankan skrip bash dengan perintah ini:

bash ./start_services.sh

Skrip ini membuat file log terpisah untuk setiap aplikasi Flask (misalnya, home.py.log, book_details.py.log) untuk membantu Anda mengidentifikasi masalah startup. Jika skrip berhasil diselesaikan, Anda akan melihat pesan ini:

All services have been started. Access the app at http://localhost:8080/

Menguji setiap aplikasi Flask

Uji modul dengan membuka URL berikut di browser Anda:

  • Homepage: http://localhost:8080/ menampilkan halaman beranda aplikasi Cymbal Books yang termodularisasi. Halaman ini mengambil detail buku, ulasan, dan gambar dengan membuat permintaan ke modul lain.
  • Detail buku: http://localhost:8081/book/1 menampilkan detail buku dengan ID 1. Respons ini adalah data JSON yang kemudian diformat dan ditampilkan aplikasi dengan cara yang lebih mudah dibaca.
  • Ulasan buku: http://localhost:8082/book/1/reviews mengambil dan menampilkan ulasan untuk buku dengan ID 1. Ulasan dalam format JSON. Modul halaman beranda meminta data ini dan mengintegrasikannya ke halaman detail buku.
  • Gambar: http://localhost:8083/images/fungi_frontier.jpg menyajikan gambar sampul buku untuk Fungi Frontier. Jika URL sudah benar, gambar akan dimuat langsung di browser Anda.

Hentikan aplikasi Flask

Setelah selesai menguji, hentikan semua aplikasi Flask dengan perintah ini:

kill $(cat home.py.pid book_details.py.pid book_reviews.py.pid images.py.pid)

Ringkasan

Tutorial ini menunjukkan cara memodularisasi monolit Cymbal Books. Prosesnya terdiri dari langkah-langkah berikut:

  1. Mengidentifikasi komponen berbeda aplikasi
  2. Membuat modul
  3. Memastikan bahwa setiap modul hanya memiliki akses ke data yang dibutuhkannya

Kemudian, Anda menguji penerapan modular di mesin lokal.

Langkah berikutnya

Dalam tutorial berikutnya, Menyiapkan aplikasi modular untuk kontainerisasi, Anda akan mempelajari cara menyiapkan aplikasi modular untuk kontainerisasi dengan memperbarui endpoint agar menggunakan nama Layanan Kubernetes, bukan localhost.