Halaman ini diterjemahkan oleh Cloud Translation API.

Jalur Pembelajaran: Mengubah monolith menjadi aplikasi GKE - Menempatkan aplikasi modular dalam container

Standard

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

Jalur pembelajaran terdiri dari tutorial berikut:

Ringkasan
Memahami monolith
Modularisasi monolit
Menyiapkan aplikasi modular untuk di-build dalam container
Memasukkan aplikasi modular ke dalam container (tutorial ini)
Men-deploy aplikasi ke cluster GKE

Dalam tutorial sebelumnya, Menyiapkan aplikasi modular untuk containerisasi, Anda melihat perubahan yang perlu dilakukan pada aplikasi Cymbal Books versi modular untuk menyiapkannya bagi containerisasi. Dalam tutorial ini, Anda akan membuat container aplikasi.

Biaya

Anda dapat menyelesaikan tutorial ini tanpa dikenai biaya apa pun. Namun, mengikuti langkah-langkah dalam tutorial berikutnya dalam seri ini akan menimbulkan biaya pada akun Google 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 ringkasan seluruh seri, dan link ke tutorial tertentu, lihat Jalur Pembelajaran: Mengubah aplikasi monolitik menjadi aplikasi GKE - Ringkasan.

Menyiapkan lingkungan Anda

Di bagian ini, Anda akan menyiapkan lingkungan tempat Anda membuat aplikasi modular dalam penampung. Secara khusus, Anda akan melakukan langkah-langkah berikut:

Pilih atau buat Google Cloud project
Aktifkan API yang diperlukan
Menghubungkan Cloud Shell ke Google Cloud project Anda
Tetapkan variabel lingkungan default
Buat repositori di Artifact Registry
Mengonfigurasi Docker untuk Artifact Registry
Mendapatkan kode tutorial

Pilih atau buat Google Cloud project

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Make sure that billing is enabled for your Google Cloud project.

Mengaktifkan API yang diperlukan

Untuk menggunakan image container dan Kubernetes di project Google Cloud Anda, Anda perlu mengaktifkan API berikut:

Artifact Registry API: API ini mengaktifkan Artifact Registry, yang merupakan layanan untuk menyimpan dan mengelola image container Anda.
Kubernetes Engine API: API ini menyediakan akses ke GKE.

Untuk mengaktifkan API ini, buka aktifkan API di konsol Google Cloud .

Hubungkan Cloud Shell ke project Google Cloud Anda

Setelah menyiapkan project Google Cloud , Anda perlu meluncurkan instance Cloud Shell dan menghubungkannya ke project Google Cloud. Cloud Shell adalah alat command line yang memungkinkan Anda membuat dan mengelola resource project langsung dari browser. Cloud Shell telah diinstal sebelumnya dengan dua alat penting: gcloud CLI dan kubectl CLI. Dalam tutorial ini, Anda akan menggunakan gcloud CLI untuk berinteraksi dengan Google Cloud dan dalam tutorial berikutnya, Anda akan menggunakan kubectl CLI untuk mengelola aplikasi Cymbal Books yang berjalan di GKE.

Untuk menghubungkan instance Cloud Shell dengan project Google Cloud Anda, ikuti langkah-langkah berikut:

Buka konsol Google Cloud :

Google Cloud console
Di konsol, klik tombol Activate Cloud Shell:

Sesi Cloud Shell akan terbuka di dalam frame yang lebih rendah di konsol.
Tetapkan project default Anda di Google Cloud CLI menggunakan perintah berikut:
```
gcloud config set project PROJECT_ID
```
Ganti PROJECT_ID dengan project ID dari project yang Anda buat atau pilih di bagian sebelumnya, Pilih atau buat project Google Cloud . 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.

Menetapkan variabel lingkungan default

Untuk menyederhanakan perintah yang Anda jalankan di sepanjang tutorial ini, Anda sekarang akan menetapkan beberapa variabel lingkungan di Cloud Shell. Variabel ini menyimpan nilai seperti ID project, region repositori, dan tag gambar. Setelah menentukan variabel ini, Anda dapat menggunakannya kembali di beberapa perintah dengan merujuk nama variabel (misalnya, $REPOSITORY_NAME) daripada mengetik ulang atau mengganti nilai setiap kali. Pendekatan ini membuat tutorial lebih mudah diikuti dan mengurangi risiko kesalahan.

Untuk menyiapkan lingkungan Anda dengan Cloud Shell, lakukan langkah-langkah berikut:

export PROJECT_ID=$(gcloud config get project)
export REPOSITORY_REGION=REPOSITORY_REGION
export REPOSITORY_NAME=REPOSITORY_NAME
export REPOSITORY_DESCRIPTION="REPOSITORY_DESCRIPTION"
export TAG=TAG

Ganti kode berikut:

REPOSITORY_REGION: region tempat Anda ingin menghosting repositori Artifact Registry. Misalnya, us-central1 (Iowa), us-west1 (Oregon), atau europe-west1 (Belgia). Untuk mengetahui daftar lengkap region, lihat Region dan Zona.
REPOSITORY_NAME: nama repositori Anda. Contoh, book-review-service-repo.
REPOSITORY_DESCRIPTION: deskripsi singkat tentang tujuan repositori. Contoh, "Repository for storing Docker images for the book review service".
TAG: tag yang ingin Anda terapkan ke gambar. Tag adalah label yang dapat Anda lampirkan ke versi tertentu dari image penampung. Anda dapat menggunakan konvensi penamaan tag seperti ini untuk menunjukkan berbagai versi image secara jelas:
- v1
- v1.2.3
- Tag deskriptif, seperti feature-x-dev
- Tag yang menunjukkan lingkungan, seperti test

Membuat repositori di Artifact Registry

Selanjutnya, Anda membuat repositori di Artifact Registry. Repositori adalah lokasi penyimpanan tempat Anda menyimpan image container. Saat membuat image penampung, Anda memerlukan tempat untuk menyimpannya agar dapat di-deploy ke cluster Kubernetes nanti. Artifact Registry memungkinkan Anda membuat dan mengelola repositori ini dalam project Google Cloud Anda.

Untuk membuat repositori di Artifact Registry, jalankan perintah berikut:

gcloud artifacts repositories create ${REPOSITORY_NAME} \
    --repository-format=docker \
    --location=${REPOSITORY_REGION} \
    --description="${REPOSITORY_DESCRIPTION}"

Output yang berhasil dari perintah akan terlihat seperti berikut:

Waiting for operation [...] to complete...done.
Created repository [book-review-service-repo].

Mengonfigurasi Docker untuk Artifact Registry

Selanjutnya, Anda mengonfigurasi Docker agar dapat berkomunikasi secara aman dengan Artifact Registry Google Cloud. Docker adalah alat yang dapat Anda gunakan untuk mengemas dan menjalankan software secara konsisten di berbagai lingkungan. Anda akan mempelajari lebih lanjut cara kerja Docker di bagian berikutnya. Untuk saat ini, Anda perlu mengonfigurasinya agar dapat terhubung ke Artifact Registry.

Jika tidak mengonfigurasi Docker dengan cara ini, Anda tidak dapat mengirim image container ke Artifact Registry (tugas yang akan Anda lakukan nanti dalam tutorial ini). Anda juga tidak dapat menarik image container dari Artifact Registry dan men-deploy-nya ke cluster GKE (tugas yang akan Anda lakukan dalam tutorial berikutnya).

Untuk mengonfigurasi Docker agar dapat melakukan autentikasi dengan Artifact Registry, jalankan perintah ini:

gcloud auth configure-docker ${REPOSITORY_REGION}-docker.pkg.dev

Mendapatkan kode tutorial

Setelah lingkungan Cloud Shell dikonfigurasi, Anda perlu mendownload kode tutorial di dalam Cloud Shell. Meskipun sebelumnya Anda telah meng-clone repositori di komputer lokal, Anda harus meng-clone-nya lagi di sini pada instance Cloud Shell Anda.

Meskipun tutorial ini dapat diselesaikan di komputer lokal, Anda harus menginstal dan mengonfigurasi beberapa alat secara manual seperti Docker, kubectl, dan gcloud CLI. Menggunakan Cloud Shell lebih mudah karena sudah dikonfigurasi sebelumnya dengan semua alat ini.

Di instance Cloud Shell Anda, jalankan perintah berikut untuk meng-clone repositori GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

Dasar-dasar containerisasi: image container, container, dan Dockerfile

Setelah menyiapkan lingkungan dan mendownload kode yang di-container, Anda siap membuat container aplikasi. Membuat container aplikasi terdiri dari penggunaan Dockerfile untuk mengemas setiap modul Cymbal Books (halaman beranda, detail buku, gambar, dan ulasan buku) ke dalam image container. Saat aplikasi di-deploy ke cluster GKE, Kubernetes menggunakan image container ini untuk membuat container yang berjalan di cluster.

Bagian berikut menjelaskan konsep ini secara mendetail.

Apa itu containerisasi?

Containerisasi mengemas modul dan semua dependensinya, seperti library dan file konfigurasi, ke dalam unit yang disebut image container. Developer menggunakan image container ini untuk membuat dan menjalankan container di seluruh lingkungan—dari laptop developer hingga server pengujian atau cluster Kubernetes produksi.

Apa itu image container?

Image container berisi semua file yang diperlukan untuk menjalankan aplikasi. File ini mencakup kode aplikasi itu sendiri, library sistem, lingkungan runtime (misalnya, interpreter Python), data statis, dan dependensi lainnya.

Dalam tutorial ini, Anda akan membuat image container untuk setiap modul aplikasi ulasan buku.

Apa itu penampung?

Container adalah lingkungan terisolasi tempat kode dari image container berjalan. Anda dapat membuat container dengan dua cara: menggunakan perintah docker run untuk pengujian selama pengembangan, atau dengan men-deploy image container ke cluster Kubernetes.

Dalam aplikasi Cymbal Books versi yang di-container, setiap modul dari aplikasi modular berjalan di container-nya sendiri:

Container halaman beranda menjalankan modul halaman beranda dan menangani permintaan ke /.
Penampung detail buku menjalankan modul detail buku dan menyajikan data untuk endpoint seperti /book/1 atau /book/3.
Penampung ulasan buku menjalankan modul ulasan buku dan mengelola permintaan ke endpoint seperti /book/2/reviews.
Container gambar menjalankan modul gambar dan menayangkan gambar sampul buku untuk endpoint seperti /images/fungi_frontier.jpg.

Keunggulan utama container adalah Kubernetes dapat otomatis membuat lebih banyak container jika diperlukan. Misalnya, jika banyak pengguna membaca ulasan buku, Kubernetes dapat memulai penampung ulasan buku tambahan untuk menangani beban.

Untuk menerapkan penskalaan di aplikasi modular yang tidak menggunakan penampung, Anda harus menulis kode kustom untuk meluncurkan instance baru modul dan mendistribusikan traffic di antaranya. Dengan Kubernetes, kemampuan penskalaan ini sudah tersedia: Anda tidak perlu menulis kode penskalaan kustom apa pun.

Apa itu Dockerfile?

Dockerfile adalah skrip yang menentukan cara memaketkan modul ke dalam image container. Dalam tutorial ini, Anda tidak perlu membuat Dockerfile apa pun—Dockerfile tersebut sudah disediakan untuk Anda di repositori GitHub yang Anda clone sebelumnya. Setiap direktori modul di salinan lokal kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/ berisi Dockerfile-nya sendiri.

Misalnya, Anda dapat menemukan Dockerfile modul home_app di instance Cloud Shell Anda di kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/home_app/Dockerfile. Dockerfile ini akan terlihat seperti berikut:

# Dockerfile for home_app
FROM python:3.9-slim #line 1
WORKDIR /app #line 2
COPY requirements.txt . #line 3
RUN pip install --no-cache-dir -r requirements.txt #line 4
COPY home_app.py . #line 5
COPY templates/ ./templates/ #line 6
COPY static/ ./static/ #line 7
CMD ["python", "home_app.py"] #line 8

Dockerfile ini melakukan langkah-langkah berikut untuk membuat image container untuk modul home_app:

Baris 1: FROM python:3.9-slim mendownload interpreter Python 3.9 dan file yang diperlukan ke dalam image container. File ini memungkinkan modul berjalan.
Baris 2: WORKDIR /app membuat direktori bernama /app di dalam container dan menetapkan direktori ini sebagai direktori kerja saat ini. Semua perintah yang dijalankan di dalam container akan dijalankan dari dalam direktori ini.
Baris 3 dan 4: COPY requirements.txt . menyalin file requirements.txt dari komputer lokal Anda ke direktori /app image container. File requirements.txt mencantumkan semua library Python yang diperlukan oleh home_app.py. Baris RUN pip install menginstal library tersebut ke dalam image container.
Baris 5 hingga 7: Perintah COPY yang muncul di baris ini menyalin kode modul (home_app.py) dan file pendukungnya (template dan aset statis) ke direktori /app dalam image container.
Baris 8: CMD menentukan perintah default yang dijalankan Docker saat container dimulai. Dalam Dockerfile ini, CMD ["python", "home_app.py"] memberi tahu Docker untuk menggunakan interpreter Python guna menjalankan modul home_app.py secara otomatis saat container diluncurkan.

Cara containerisasi dapat menerapkan isolasi data yang lebih ketat

Baris 5 hingga 7 Dockerfile, yang dijelaskan di bagian sebelumnya, menunjukkan cara penampungan dapat menerapkan isolasi data yang lebih ketat daripada versi aplikasi yang dimodularisasi. Dalam tutorial sebelumnya, di bagian Beri setiap modul akses ke data yang dibutuhkannya saja, Anda mempelajari bahwa versi aplikasi modular mengatur data ke dalam direktori terpisah, tetapi modul masih berbagi sistem file yang sama dan berpotensi mengakses data satu sama lain.

Di sini, dalam aplikasi versi yang di-container, setiap container modul hanya menyertakan file yang diperlukan. Misalnya, jika modul home_app tidak memerlukan akses ke data ulasan buku, data tersebut tidak ada di dalam penampung home_app. Secara default, sebuah penampung tidak dapat mengakses file dari penampung lain kecuali dikonfigurasi secara eksplisit untuk melakukannya. Hal ini membantu memastikan bahwa setiap modul sepenuhnya terisolasi, dan juga membantu mencegah akses data yang tidak disengaja atau tidak sah.

Di bagian berikutnya, Anda akan melihat cara perintah docker build mengambil Dockerfile sebagai input, dan mengikuti petunjuk dalam Dockerfile untuk membuat image container.

Membangun image container menggunakan Docker

Di bagian ini, Anda akan membangun image container Docker untuk setiap modul ulasan buku dan mengirimkannya ke repositori Artifact Registry Anda. Anda akan menggunakan image container ini dalam tutorial berikutnya untuk men-deploy dan menjalankan aplikasi contoh Cymbal Books di Kubernetes.

Buka direktori root aplikasi dalam container:

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

Buat image container menggunakan perintah docker build:

docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/home-app:${TAG} ./home_app
docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app:${TAG} ./book_details_app
docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app:${TAG} ./book_reviews_app
docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app:${TAG} ./images_app

Lihat image container yang dibuat di dalam instance Cloud Shell Anda:
```
docker images
```
Pastikan gambar berikut muncul dalam daftar:
- home-app
- book-details-app
- book-reviews-app
- images-app
Jika keempat image tercantum, Anda berhasil membuat image container.

Menguji container di Cloud Shell

Untuk memverifikasi bahwa image container dibuat dengan benar, Anda dapat menjalankannya sebagai container dan menguji endpointnya di Cloud Shell.

Kontainer book_details_app, book_reviews_app, dan images_app dapat diuji satu per satu karena tidak perlu berkomunikasi satu sama lain. Namun, menguji container home_app menggunakan Docker sulit karena home_app dikonfigurasi untuk menemukan container lain yang menggunakan nama layanan seperti http://book-details-service:8081.

Meskipun home_app container dapat diuji dengan menemukan alamat IP setiap container dan mengonfigurasi home_app untuk menggunakannya, bukan nama layanan, pendekatan ini memerlukan banyak upaya. Sebaiknya tunda pengujian container home_app hingga setelah Anda men-deploy aplikasi ke cluster Kubernetes. Setelah aplikasi berada di cluster, Anda dapat menentukan apakah modul smart home berfungsi dengan benar.

Ikuti langkah-langkah berikut untuk menguji penampung:

Mulai penampung book_details_app, book_reviews_app, dan images_app:

docker run -d -p 8081:8080 ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app:${TAG}
docker run -d -p 8082:8080 ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app:${TAG}
docker run -d -p 8083:8080 ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app:${TAG}

Pastikan container sedang berjalan dengan mencantumkan semua container aktif:

docker ps

Output dari perintah ini akan menampilkan tiga penampung yang sedang berjalan, dengan status Up:

CONTAINER ID   IMAGE                PORTS                        STATUS
a1b2c3d4e5f6   REGION/.../details   0.0.0.0:8081->8080/tcp       Up
g7h8i9j0k1l2   REGION/.../reviews   0.0.0.0:8082->8080/tcp       Up
m3n4o5p6q7r8   REGION/.../images    0.0.0.0:8083->8080/tcp       Up

Untuk menguji endpoint container book_details_app, gunakan perintah curl berikut:

curl http://localhost:8081/books
curl http://localhost:8081/book/1
curl http://localhost:8081/book/2
curl http://localhost:8081/book/3

Setiap perintah ini menampilkan data dalam format JSON. Misalnya, output dari perintah curl http://localhost:8081/book/1 terlihat seperti ini:

{"author":"Aria Clockwork","description":"In a world where time is a tangible substance, a young clockmaker discovers she can manipulate the fabric of time itself, leading to unforeseen consequences in her steampunk-inspired city.","id":1,"image_url":"zephyrs_timepiece.jpg","title":"Zephyr's Timepiece","year":2023}

Ambil ulasan buku dari penampung book_reviews_app menggunakan perintah curl ini:
```
curl http://localhost:8082/book/1/reviews
```
Perintah ini menampilkan daftar 20 ulasan buku 1 dalam format JSON. Berikut contoh satu ulasan dari daftar:
```
{
"content": "The concept of time as a tangible substance is brilliantly explored in 'Zephyr's Timepiece'.",
"rating": 5
}
```
Uji container images_app:
1. Klik tombol **Web Preview**
2. Pilih Ubah port, lalu masukkan 8083. Jendela browser akan terbuka dengan URL yang mirip dengan ini:
```
https://8083-your-instance-id.cs-your-region.cloudshell.dev/?authuser=0
```
3. Hapus ?authuser=0 di akhir URL dan tambahkan jalur ke file gambar, seperti /images/fungi_frontier.jpg. Berikut adalah contohnya:
```
https://8083-your-instance-id.cs-your-region.cloudshell.dev/images/fungi_frontier.jpg
```
  Anda akan melihat gambar sampul buku Fungi Frontier ditampilkan di browser Anda.
Setelah pengujian, hentikan container untuk melepaskan resource:
1. Tampilkan daftar container yang sedang berjalan dan temukan ID container-nya:
```
docker ps
```
2. Hentikan setiap container:
```
docker stop CONTAINER_ID
```
  Ganti CONTAINER_ID dengan ID penampung yang ingin Anda hentikan.

Mengirim image container ke Artifact Registry

Sebelum Anda dapat men-deploy aplikasi ke cluster Kubernetes, image container harus disimpan di lokasi yang dapat diakses oleh cluster. Pada langkah ini, Anda akan mengirim image ke repositori Artifact Registry yang Anda buat sebelumnya. Dalam tutorial berikutnya, Anda akan men-deploy image tersebut dari repositori Artifact Registry ke cluster GKE:

Untuk mengirim image container ke Artifact Registry, jalankan perintah berikut:

docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/home-app:${TAG}
docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app:${TAG}
docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app:${TAG}
docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app:${TAG}

Setelah mengirim gambar, verifikasi bahwa gambar berhasil diupload dengan mencantumkannya:

gcloud artifacts docker images list ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}

Anda akan melihat output yang mirip dengan yang berikut:

Listing items under project ${PROJECT_ID}, location ${REPOSITORY_REGION}, repository ${REPOSITORY_NAME}.

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app
DIGEST: sha256:f7b78f44d70f2eedf7f7d4dc72c36070e7c0dd05daa5f473e1ebcfd1d44b95b1
CREATE_TIME: 2024-11-14T00:38:53
UPDATE_TIME: 2024-11-14T00:38:53
SIZE: 52260143

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app
DIGEST: sha256:875ac8d94ef54db2ff637e49ad2d1c50291087623718b854a34ad657748fac86
CREATE_TIME: 2024-11-14T00:39:04
UPDATE_TIME: 2024-11-14T00:39:04
SIZE: 52262041

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/home-app
DIGEST: sha256:70ddc54ffd683e2525d87ee0451804d273868c7143d0c2a75ce423502c10638a
CREATE_TIME: 2024-11-14T00:33:56
UPDATE_TIME: 2024-11-14T00:33:56
SIZE: 52262412

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app
DIGEST: sha256:790f0d8c2f83b09dc3b431c4c04d7dc68254fecc76c48f00a83babc2a5dc0484
CREATE_TIME: 2024-11-14T00:39:15
UPDATE_TIME: 2024-11-14T00:39:15
SIZE: 53020815

Output mencakup detail berikut untuk setiap gambar:

IMAGE: jalur repositori dan nama image.
DIGEST: ID unik untuk gambar.
CREATE_TIME atau UPDATE_TIME: saat gambar dibuat atau terakhir diubah.
SIZE: ukuran gambar dalam byte.

Perbarui manifes Kubernetes dengan jalur ke image container

Seperti yang telah Anda pelajari dalam tutorial sebelumnya, Menyiapkan aplikasi modular untuk penampungan, manifes Kubernetes adalah file YAML yang menentukan cara aplikasi Anda berjalan di cluster Kubernetes. Hal ini mencakup detail seperti berikut:

Modul aplikasi Anda (misalnya,home-app, book-details-app)
Jalur ke image container
Detail konfigurasi seperti batas resource
Definisi layanan untuk merutekan permintaan antar-modul

Di bagian ini, Anda akan memperbarui file manifes yang sama dengan yang Anda tinjau dalam tutorial sebelumnya. File tersebut adalah kubernetes-manifest.yaml dan berisi nilai placeholder untuk jalur gambar. Anda harus mengganti placeholder tersebut dengan jalur sebenarnya ke image container yang Anda kirim ke repositori Artifact Registry di bagian sebelumnya.

Untuk memperbarui file manifes Kubernetes kubernetes-manifest.yaml, ikuti langkah-langkah berikut:

Di Cloud Shell, buka direktori containerized/, yang berisi file manifes Kubernetes kubernetes-manifest.yaml:
```
cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/
```
Buka file kubernetes-manifest.yaml di editor teks:
```
vim kubernetes-manifest.yaml
```
Temukan kolom image yang berisi placeholder seperti ini:
```
image: REPOSITORY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_NAME/home-app:TAG
```
Ganti setiap placeholder dengan jalur sebenarnya ke image container yang Anda kirim ke Artifact Registry:
- REPOSITORY_REGION: region yang Anda tentukan saat membuat repositori di Artifact Registry.
- PROJECT_ID: ID project Anda, yang dapat Anda temukan di halaman pemilih project. Google Cloud
- REPOSITORY_NAME: nama repositori Anda, yang Anda tentukan saat Anda membuat repositori di Artifact Registry. Misalnya, book-review-service-repo.
- TAG: tag yang Anda pilih saat Anda Membangun image container.
Berikut tampilan jalur setelah penggantian ini dilakukan:
```
image:us-west1-docker.pkg.dev/your-project-id/book-review-service-repo/home-app:v1
```
Perbarui jalur untuk semua image container:
- home-app
- book-details-app
- book-reviews-app
- images-app
Setelah memperbarui jalur, simpan file manifes dan tutup editor. Misalnya, jika Anda menggunakan vim, tekan Esc untuk masuk ke mode perintah, ketik wq, lalu tekan Enter untuk menyimpan dan keluar.

Manifes Kubernetes Anda kini dikonfigurasi untuk men-deploy image container dari repositori Artifact Registry ke cluster Kubernetes.

Ringkasan

Dalam tutorial ini, Anda menyiapkan aplikasi Cymbal Books modular untuk di-deploy ke cluster Kubernetes dengan melakukan tugas-tugas berikut:

Siapkan project Google Cloud dan konfigurasi Cloud Shell untuk lingkungan Anda.
Meninjau Dockerfile yang disediakan untuk setiap modul aplikasi.
Membangun image container untuk modul aplikasi menggunakan Docker.
Menguji container di Cloud Shell untuk memverifikasi fungsinya.
Mengirim image container ke Artifact Registry untuk penyimpanan.
Memperbarui manifes Kubernetes untuk menggunakan jalur image container yang benar dari Artifact Registry.

Langkah berikutnya

Dalam tutorial berikutnya, Men-deploy aplikasi ke cluster GKE, Anda akan men-deploy aplikasi dalam container ke cluster GKE.