GSP021

Ringkasan

Kubernetes adalah project open source (tersedia di kubernetes.io) yang dapat berjalan di berbagai lingkungan, dari laptop hingga cluster multi node dengan ketersediaan tinggi, dari cloud publik hingga deployment lokal, dan dari virtual machine hingga server khusus (bare metal).

Untuk lab ini, dengan menggunakan lingkungan terkelola seperti Kubernetes Engine, Anda dapat berfokus pada pengalaman menggunakan Kubernetes tanpa perlu repot-repot menyiapkan infrastrukturnya. Kubernetes Engine merupakan lingkungan terkelola untuk men-deploy aplikasi dalam kontainer. Kubernetes Engine menghadirkan inovasi terbaru dalam produktivitas developer, efisiensi resource, operasi otomatis, dan fleksibilitas open source untuk mempercepat waktu penyiapan produk Anda.

Catatan: App dihosting di GitHub dan menyediakan contoh aplikasi 12 Faktor. Di lab ini, Anda akan menggunakan image Docker berikut:

kelseyhightower/monolith - Monolit yang mencakup service auth dan hello.

kelseyhightower/auth - Microservice auth. Menghasilkan token JWT untuk pengguna yang terautentikasi.

kelseyhightower/hello - Microservice hello. Menyapa pengguna yang terautentikasi.

nginx - Frontend untuk service auth dan hello.

Tujuan

Di lab ini, Anda akan mempelajari cara:

• Menyediakan cluster Kubernetes lengkap menggunakan Kubernetes Engine.
• Men-deploy dan mengelola container Docker menggunakan kubectl.
• Memecah aplikasi menjadi microservice menggunakan Deployment dan Service Kubernetes.

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.

Google Kubernetes Engine

1. Di lingkungan Cloud Shell, ketik perintah berikut untuk menetapkan zona:

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

2. Aktifkan cluster yang akan digunakan di lab ini:

gcloud container clusters create io --zone {{{project_0.default_zone|Zone}}} Anda diautentikasi ke cluster secara otomatis pada saat pembuatan. Jika koneksi ke Cloud Shell terputus dengan alasan apa pun, jalankan perintah gcloud container clusters get-credentials io untuk mengautentikasi ulang. Catatan: Pembuatan cluster memerlukan waktu beberapa menit. Kubernetes Engine menyediakan beberapa Virtual Machine di belakang layar yang dapat Anda gunakan untuk bereksperimen.

Tugas 1. Mendapatkan kode contoh

1. Salin kode sumber dari command line Cloud Shell:

gsutil cp -r gs://spls/gsp021/* .

2. Buka direktori yang dibutuhkan oleh lab ini:

cd orchestrate-with-kubernetes/kubernetes

3. Lihat daftar file untuk mengetahui file yang akan Anda kerjakan:

ls

Contoh memiliki tata letak berikut:

deployments/ /* Deployment manifests */ ... nginx/ /* nginx config files */ ... pods/ /* Pod manifests */ ... services/ /* Services manifests */ ... tls/ /* TLS certificates */ ... cleanup.sh /* Cleanup script */

Setelah Anda memiliki kodenya, mari kita coba menggunakan Kubernetes.

Tugas 2. Demo Kubernetes Singkat

Cara termudah untuk memulai Kubernetes adalah dengan menggunakan perintah kubectl create.

1. Gunakan perintah tersebut untuk meluncurkan satu instance container nginx:

kubectl create deployment nginx --image=nginx:1.10.0

Kubernetes telah membuat deployment, dan deployment akan dijelaskan lebih lanjut nanti. Namun, untuk saat ini, Anda hanya perlu mengetahui bahwa deployment menjaga pod tetap aktif dan berjalan meskipun node tempatnya berjalan tersebut gagal.

Di Kubernetes, semua container berjalan dalam pod.

2. Gunakan perintah kubectl get pods untuk melihat container nginx yang berjalan:

kubectl get pods

3. Setelah status container nginx menandakan Running (berjalan), Anda dapat mengeksposnya ke luar Kubernetes menggunakan perintah kubectl expose:

kubectl expose deployment nginx --port 80 --type LoadBalancer

Jadi, apa yang baru saja terjadi? Di balik layar, Kubernetes membuat Load Balancer eksternal yang dilengkapi dengan alamat IP publik. Tiap klien yang membuka alamat IP publik tersebut akan dirutekan ke pod di belakang service. Dalam hal ini, pod tersebut adalah pod nginx.

4. Sekarang, lihat daftar service menggunakan perintah kubectl get services:

kubectl get services Catatan: Mungkin perlu waktu beberapa detik hingga kolom ExternalIP untuk service Anda terisi. Hal ini wajar. Cukup jalankan kembali perintah kubectl get services tiap beberapa detik hingga kolom terisi.

5. Tambahkan IP Eksternal ke perintah ini untuk membuka container Nginx dari jarak jauh:

curl http://<External IP>:80

Dan, berhasil! Kubernetes mendukung alur kerja yang siap pakai menggunakan perintah kubectl untuk menjalankan dan mengekspos.

Menguji tugas yang sudah selesai

Klik Check my progress di bawah untuk memeriksa progres lab Anda. Jika Anda berhasil membuat cluster Kubernetes dan men-deploy container Nginx, skor penilaian akan terlihat.

Membuat cluster Kubernetes dan meluncurkan container Nginx

Setelah melihat tur singkat Kubernetes, sekarang saatnya mempelajari tiap komponen dan abstraksi secara mendalam.

Tugas 3. Pod

Pod merupakan inti dari Kubernetes.

Pod mewakili dan menampung kumpulan dari satu atau beberapa container. Umumnya, jika Anda memiliki beberapa container yang sangat bergantung satu sama lain, Anda menggabungkan container ini di dalam satu pod.

Dalam contoh ini, ada pod yang berisi container monolit dan nginx.

Pod juga memiliki Volume. Volume adalah disk data yang berfungsi selama pod berfungsi, dan dapat digunakan oleh container yang ada dalam pod tersebut. Pod menyediakan namespace bersama untuk kontennya. Hal ini berarti kedua container di dalam pod pada contoh ini dapat saling berkomunikasi, dan juga memiliki volume terpasang yang sama.

Pod juga memiliki namespace jaringan bersama. Artinya, tiap pod memiliki satu Alamat IP.

Selanjutnya, mari kita pelajari pod secara lebih mendalam.

Tugas 4. Membuat pod

Pod dapat dibuat menggunakan file konfigurasi pod. Luangkan waktu untuk mempelajari file konfigurasi pod monolit.

1. Buka direktori:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Jalankan perintah berikut:

cat pods/monolith.yaml

Output menunjukkan file konfigurasi yang terbuka:

apiVersion: v1 kind: Pod metadata: name: monolith labels: app: monolith spec: containers: - name: monolith image: kelseyhightower/monolith:1.0.0 args: - "-http=0.0.0.0:80" - "-health=0.0.0.0:81" - "-secret=secret" ports: - name: http containerPort: 80 - name: health containerPort: 81 resources: limits: cpu: 0.2 memory: "10Mi"

Ada beberapa hal yang perlu Anda perhatikan di sini. Anda akan melihat bahwa:

• Pod terdiri atas satu container (monolit).
• Anda meneruskan beberapa argumen ke container saat pod dimulai.
• Anda membuka port 80 untuk traffic http.

3. Buat pod monolit menggunakan kubectl:

kubectl create -f pods/monolith.yaml

4. Periksa pod Anda. Gunakan perintah kubectl get pods untuk melihat daftar semua pod yang berjalan di namespace default:

kubectl get pods Catatan: Mungkin perlu waktu beberapa detik hingga pod monolit aktif dan berjalan. Image container monolit perlu diambil dari Docker Hub sebelum pod dapat dijalankan.

5. Setelah pod monolit berjalan, gunakan perintah kubectl describe untuk mendapatkan informasi selengkapnya tentang pod monolit:

kubectl describe pods monolith

Anda akan melihat berbagai informasi tentang pod monolit, termasuk alamat IP dan log aktivitas Pod. Informasi ini dapat berguna saat memecahkan masalah.

Kubernetes mempermudah pembuatan pod dengan menjelaskannya dalam file konfigurasi dan melihat informasi saat pod dijalankan. Di bagian ini, Anda sudah memiliki kemampuan untuk membuat semua pod yang diperlukan deployment.

Tugas 5. Berinteraksi dengan pod

Secara default, pod mendapatkan alamat IP pribadi yang tidak dapat dijangkau di luar cluster. Gunakan perintah kubectl port-forward untuk memetakan port lokal ke port di dalam pod monolit.

Catatan: Mulai saat ini, lab akan meminta Anda untuk bekerja dalam beberapa tab Cloud Shell guna menyiapkan komunikasi di antara pod. Tiap perintah yang dijalankan dalam shell perintah kedua atau ketiga akan disebutkan dalam petunjuk perintah.

1. Buka terminal Cloud Shell kedua. Sekarang Anda memiliki dua terminal, satu terminal untuk menjalankan perintah kubectl port-forward dan satu lagi untuk menjalankan perintah curl.

2. Di terminal kedua, jalankan perintah berikut untuk menyiapkan penerusan port:

kubectl port-forward monolith 10080:80

3. Sekarang, di terminal pertama, mulai berinteraksi dengan pod Anda menggunakan curl:

curl http://127.0.0.1:10080

Ya! Container mengirimkan respons "hello" kepada Anda.

4. Sekarang gunakan perintah curl untuk melihat apa yang terjadi jika Anda membuka endpoint yang aman:

curl http://127.0.0.1:10080/secure

Maaf.

5. Coba login untuk mendapatkan kembali token autentikasi dari monolit:

curl -u user http://127.0.0.1:10080/login

6. Pada perintah login, gunakan sandi yang sangat rahasia password untuk login.

Proses login akan mencetak token JWT.

7. Karena Cloud Shell tidak dapat menangani penyalinan string panjang dengan baik, buat variabel lingkungan untuk token.

TOKEN=$(curl http://127.0.0.1:10080/login -u user|jq -r '.token')

8. Saat dimintai sandi host, masukkan kembali sandi yang sangat rahasia, yaitu password.

9. Salin perintah ini, lalu gunakan token untuk membuka endpoint yang aman dengan curl:

curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:10080/secure

Di bagian ini, Anda seharusnya menerima respons dari aplikasi yang memberitahukan bahwa semuanya berjalan dengan lancar.

10. Gunakan perintah kubectl logs untuk melihat log Pod monolit.

kubectl logs monolith

11. Buka terminal ketiga, lalu gunakan flag -f untuk mendapatkan aliran data log yang terjadi secara real time:

kubectl logs -f monolith

12. Sekarang jika Anda menggunakan curl di terminal pertama untuk berinteraksi dengan monolit, Anda dapat melihat log diperbarui (di terminal ketiga):

curl http://127.0.0.1:10080

13. Gunakan perintah kubectl exec untuk menjalankan shell interaktif di dalam Pod Monolit. Hal ini dapat berguna saat Anda ingin memecahkan masalah dari dalam container:

kubectl exec monolith --stdin --tty -c monolith -- /bin/sh

14. Misalnya, setelah Anda memasukkan shell ke dalam container monolit, konektivitas eksternal dapat diuji menggunakan perintah ping:

ping -c 3 google.com

15. Pastikan untuk logout setelah Anda selesai menggunakan shell interaktif ini.

exit

Seperti yang dapat Anda lihat, berinteraksi dengan pod semudah menggunakan perintah kubectl. Jika Anda perlu membuka container dari jarak jauh, atau mendapatkan info shell login, Kubernetes menyediakan semua hal yang diperlukan untuk menyiapkan dan mengerjakan project Anda.

Tugas 6. Service

Pod tidak dirancang untuk persisten. Pod dapat dimulai atau dihentikan karena berbagai alasan, misalnya pemeriksaan keaktifan dan kesiapan yang gagal, dan hal ini menyebabkan masalah:

Apa yang terjadi jika Anda ingin berkomunikasi dengan kumpulan Pod? Saat dimulai ulang, pod mungkin akan memiliki alamat IP yang berbeda.

Di sinilah Service berperan. Service menyediakan endpoint stabil untuk Pod.

Service menggunakan label untuk menentukan Pod yang digunakan untuk beroperasi. Jika memiliki label yang tepat, Pod akan dideteksi dan diekspos secara otomatis oleh service.

Tingkat akses yang diberikan oleh service ke kumpulan pod bergantung pada jenis Service. Saat ini ada tiga jenis Service:

• ClusterIP (internal) -- jenis default yang berarti Service ini hanya dapat dilihat di dalam cluster,
• NodePort memberikan IP yang dapat diakses secara eksternal kepada setiap node di cluster, serta
• LoadBalancer menambahkan load balancer dari penyedia cloud yang akan meneruskan traffic dari service ke Node di dalamnya.

Sekarang Anda akan mempelajari cara:

• Membuat service
• Menggunakan pemilih label untuk mengekspos kumpulan Pod terbatas secara eksternal

Tugas 7. Membuat service

Sebelum Anda dapat membuat service, buatlah pod aman terlebih dahulu yang dapat menangani traffic https.

1. Jika direktori diubah, pastikan Anda kembali ke direktori ~/orchestrate-with-kubernetes/kubernetes:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Pelajari file konfigurasi service monolit:

cat pods/secure-monolith.yaml

3. Buat pod secure-monolith dan data konfigurasinya:

kubectl create secret generic tls-certs --from-file tls/ kubectl create configmap nginx-proxy-conf --from-file nginx/proxy.conf kubectl create -f pods/secure-monolith.yaml

Setelah Anda memiliki pod yang aman, saatnya untuk mengekspos Pod secure-monolith secara eksternal. Untuk melakukannya, buat service Kubernetes.

4. Pelajari file konfigurasi service monolit:

cat services/monolith.yaml

(Output):

kind: Service apiVersion: v1 metadata: name: "monolith" spec: selector: app: "monolith" secure: "enabled" ports: - protocol: "TCP" port: 443 targetPort: 443 nodePort: 31000 type: NodePort Beberapa hal yang perlu diperhatikan:

* Ada pemilih yang digunakan untuk menemukan dan mengekspos pod apa pun secara otomatis dengan label `app: monolith` dan `secure: enabled`.

* Sekarang, Anda harus mengekspos nodeport di sini karena inilah cara meneruskan traffic eksternal dari port 31000 ke nginx (di port 443).

5. Gunakan perintah kubectl create untuk membuat service monolit dari file konfigurasi service monolit:

kubectl create -f services/monolith.yaml

(Output):

service/monolith created

Menguji tugas yang sudah selesai

Klik Check my progress di bawah untuk memeriksa progres lab Anda. Jika Anda berhasil membuat pod dan service Monolit, skor penilaian akan terlihat.

Membuat pod dan service Monolit

Anda menggunakan port untuk mengekspos service. Hal ini berarti bentrokan port dapat terjadi jika aplikasi lain mencoba mengikat ke port 31000 di salah satu server Anda.

Umumnya, Kubernetes akan menangani penugasan port ini. Di lab ini, Anda akan memilih port untuk memudahkan konfigurasi health check nanti.

6. Gunakan perintah gcloud compute firewall-rules untuk mengizinkan traffic ke service monolit pada nodeport yang diekspos:

gcloud compute firewall-rules create allow-monolith-nodeport \ --allow=tcp:31000

Menguji tugas yang sudah selesai

Klik Check my progress di bawah untuk memeriksa progres lab Anda. Jika Anda berhasil membuat aturan firewall untuk mengizinkan traffic TCP di port 31000, skor penilaian akan terlihat.

Mengizinkan traffic ke service monolit pada nodeport yang diekspos

Setelah menyiapkan semuanya, Anda seharusnya dapat membuka service secure-monolith dari luar cluster tanpa perlu menggunakan penerusan port.

1. Pertama-tama, dapatkan alamat IP eksternal untuk salah satu node.

gcloud compute instances list

2. Sekarang coba buka service secure-monolith menggunakan curl:

curl -k https://<EXTERNAL_IP>:31000

Maaf. Waktu habis. Apa yang salah?

Catatan: Sekarang saatnya menguji pengetahuan Anda secara singkat.

Gunakan perintah berikut untuk menjawab pertanyaan di bawah ini:

kubectl get services monolith

kubectl describe services monolith

Pertanyaan:

Mengapa Anda tidak mendapatkan respons dari service monolit?

Berapa banyak endpoint yang dimiliki service monolit?

Label apa saja yang harus dimiliki Pod agar dapat dideteksi oleh service monolit?

Petunjuk: ada kaitannya dengan label. Anda akan memperbaiki masalah ini di bagian berikutnya.

Tugas 8. Menambahkan label ke pod

Saat ini service monolit tidak memiliki endpoint. Salah satu cara untuk memecahkan masalah seperti ini adalah menggunakan perintah kubectl get pods dengan kueri label.

1. Anda dapat melihat bahwa ada beberapa pod yang berjalan menggunakan label monolit.

kubectl get pods -l "app=monolith"

2. Namun, bagaimana dengan "app=monolith" dan "secure=enabled"?

kubectl get pods -l "app=monolith,secure=enabled"

Kueri label ini tidak menampilkan hasil apa pun. Sepertinya label "secure=enabled" perlu ditambahkan ke pod tersebut.

3. Gunakan perintah kubectl label untuk menambahkan label secure=enabled yang tidak ada ke Pod secure-monolith. Setelah itu, Anda dapat memeriksa dan melihat bahwa label telah diperbarui.

kubectl label pods secure-monolith 'secure=enabled' kubectl get pods secure-monolith --show-labels

4. Setelah pod diberi label dengan benar, lihat daftar endpoint di service monolit:

kubectl describe services monolith | grep Endpoints

Anda berhasil membuat endpoint!

5. Uji endpoint dengan membuka kembali salah satu node.

gcloud compute instances list curl -k https://<EXTERNAL_IP>:31000

Aha! Kita berhasil terhubung.

Menguji tugas yang sudah selesai

Klik Check my progress di bawah untuk memeriksa progres lab Anda. Jika Anda berhasil menambahkan label ke pod monolit, skor penilaian akan terlihat.

Menambahkan Label ke Pod

Tugas 9. Men-deploy aplikasi dengan Kubernetes

Sasaran lab ini adalah mempersiapkan Anda melakukan penskalaan dan mengelola container dalam produksi. Di sinilah Deployment berperan. Deployment adalah cara deklaratif untuk memastikan jumlah Pod yang berjalan sama dengan jumlah Pod yang diinginkan, yang ditentukan oleh pengguna.

Manfaat utama Deployment adalah menangani detail tingkat rendah dalam mengelola Pod. Di balik layar, Deployment menggunakan Kumpulan Replika untuk mengelola proses memulai dan menghentikan Pod. Jika Pod perlu diupdate atau diskalakan, Deployment akan menangani prosesnya. Deployment juga akan menangani proses mulai ulang Pod jika Pod terhenti karena alasan tertentu.

Lihat contoh singkat:

Pod terikat dengan durasi Node tempatnya dibuat. Pada contoh di atas, Node3 terhenti (diikuti dengan Pod). Alih-alih membuat Pod baru dan mencari Node untuknya secara manual, Deployment membuat Pod baru dan memulainya di Node2.

Cukup bagus!

Sekarang saatnya menggabungkan semua yang telah Anda pelajari tentang Pod dan Service untuk memecah aplikasi monolitik menjadi beberapa Service yang berukuran lebih kecil menggunakan Deployment.

Tugas 10. Membuat deployment

Anda akan memecah aplikasi monolitik menjadi tiga bagian yang terpisah:

• auth - Menghasilkan token JWT untuk pengguna yang terautentikasi.
• hello - Menyapa pengguna yang terautentikasi.
• frontend - Merutekan traffic ke service auth dan hello.

Deployment siap dibuat untuk tiap service. Setelah itu, Anda akan menentukan service internal untuk deployment auth dan hello, serta service eksternal untuk deployment frontend. Setelah selesai, Anda dapat berinteraksi dengan setiap microservice, sama seperti dengan Monolit. Namun, kini tiap bagian dapat diskalakan dan di-deploy secara terpisah.

1. Mulai dengan mempelajari file konfigurasi deployment auth.

cat deployments/auth.yaml

(Output)

apiVersion: apps/v1 kind: Deployment metadata: name: auth spec: selector: matchlabels: app: auth replicas: 1 template: metadata: labels: app: auth track: stable spec: containers: - name: auth image: "kelseyhightower/auth:2.0.0" ports: - name: http containerPort: 80 - name: health containerPort: 81 ...

Deployment membuat 1 replika, dan Anda menggunakan container auth versi 2.0.0.

Saat Anda menjalankan perintah kubectl create untuk membuat deployment auth, sebuah pod yang sesuai dengan data dalam manifes Deployment akan dibuat. Hal ini berarti Anda dapat menskalakan jumlah Pod dengan mengubah angka yang ditentukan dalam kolom Replicas.

2. Lanjutkan dan buat objek deployment Anda:

kubectl create -f deployments/auth.yaml

3. Sekarang saatnya membuat service untuk deployment auth Anda. Gunakan perintah kubectl create untuk membuat service auth:

kubectl create -f services/auth.yaml

4. Sekarang, lakukan langkah yang sama untuk membuat dan mengekspos deployment hello:

kubectl create -f deployments/hello.yaml kubectl create -f services/hello.yaml

5. Lakukan sekali lagi untuk membuat dan mengekspos Deployment frontend.

kubectl create configmap nginx-frontend-conf --from-file=nginx/frontend.conf kubectl create -f deployments/frontend.yaml kubectl create -f services/frontend.yaml Catatan: Ada satu langkah lagi untuk membuat frontend karena Anda perlu menyimpan beberapa data konfigurasi menggunakan container.

6. Berinteraksilah dengan frontend dengan mengambil IP Eksternal-nya, lalu menggunakan curl:

kubectl get services frontend Catatan: Pembuatan alamat IP eksternal membutuhkan waktu kurang lebih satu menit. Jalankan lagi perintah sebelumnya jika status kolom EXTERNAL-IP masih tertunda. curl -k https://<EXTERNAL-IP>

Anda akan mendapatkan respons balik hello.

Menguji tugas yang sudah selesai

Klik Check my progress di bawah untuk memeriksa progres lab Anda. Jika Anda berhasil membuat deployment Auth, Hello, dan Frontend, skor penilaian akan terlihat.

Membuat Deployment (Auth, Hello, dan Frontend)

Selamat!

Selamat! Anda telah berhasil mengembangkan aplikasi multi-service menggunakan Kubernetes. Dengan keterampilan yang Anda pelajari di sini, Anda dapat men-deploy aplikasi kompleks di Kubernetes menggunakan sekumpulan deployment dan service.

Langkah berikutnya/Pelajari lebih lanjut

• Anda dapat mengikuti kabar terbaru Kubernetes di X dan di blog komunitas.
• Ingat bahwa Kubernetes adalah project open source (http://kubernetes.io/) yang dihosting di GitHub. Kami selalu menanti kontribusi dan masukan dari Anda.

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 29 April 2024

Lab Terakhir Diuji pada 29 April 2024

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.