Modernisasi Aplikasi dengan Google Cloud: Bagian 2 — Kubernetes

Pada topik sebelumnya, saya membahas tentang teknologi container dan keunggulan serta perannya dalam modernisasi sebuah aplikasi. Salah satu teknologi yang juga sangat erat dalam topik ini adalah Kubernetes. Untuk memahami Kubernetes, kita perlu tau dulu alasan dibalik dibuatnya teknologi ini.

Monolith vs Microservices

Perbandingan Arsitektur Monolith dan Microservice

Terdapat 2 cara untuk membuat arsitektur aplikasi, yaitu monolitik atau microservice. Monolitik adalah model aplikasi yang menggabungkan semua fungsionalitas dari aplikasi tersebut ke dalam satu package besar dan hanya menggunakan 1 Database saja. Sebagai contoh, aplikasi e-commerce mungkin akan memiliki layanan login, search, cart, checkout, payment, dan lain-lain. Layanan-layanan ini di-deploy dalam satu Virtual Machine.

Monolitik memiliki 2 kekurangan besar yaitu terkait dengan scalability dan reliability. Pada contoh aplikasi e-commerce, pasti akan lebih banyak pengguna yang sedang melakukan pencarian barang daripada pengguna yang melakukan checkout. Hal ini membuat utilisasi layanan search akan lebih besar dari layanan checkout. Jika aplikasi menggunakan arsitektur monolitik, untuk memperbesar kapasitas layanan search, maka layanan checkout juga ikut membesar karena aplikasi menjadi 1. Hal ini membuat aplikasi tidak scalable dan dapat membuang resource yang cukup signifikan.

Dari sisi reliability, jika salah satu layanan aplikasi, misal cart mengalami error, maka seluruh aplikasi akan menjadi error. Hal ini membuat aplikasi akan mudah sekali untuk error karena semua komponennya sangat terikat atau coupled.

Dalam microservice, layanan-layanan yang ada dalam aplikasi dipecah menjadi beberapa aplikasi kecil yang disebut service. Dalam contoh aplikasi e-commerce, maka akan terdapat service login, service cart, service checkout, dan lain-lain. Service-service ini dapat di-deploy secara individu, sehingga jika utilisasi service search tinggi, maka service tersebut dapat diduplikasi sehingga memenuhi request pengguna tanpa harus menduplikasi service lainnya.

Reliability aplikasi akan meningkat pula karena dengan service yang dapat di-deploy secara individu, maka berarti aplikasi sudah tidak terikat satu sama lain atau dalam kata lain decoupled. Hal ini berarti jika salah satu service mengalami error, maka error dapat dibatasi pada service itu saja tanpa memengaruhi service lainnya.

Terus apa hubungannya dengan Kubernetes?

Penggunaan arsitektur microservice memang memiliki keunggulan dibanding dengan arsitektur monolitik. Namun, microservice bukan tanpa kekurangan. Penggunaan microservice membuat operasi aplikasi menjadi lebih rumit. Pada aplikasi monolitik, operator aplikasi hanya perlu mengoperasikan package aplikasi saja. Komunikasi antar fungsionalitas aplikasi juga terjadi di dalam aplikasi sehingga operator tidak perlu mengatur hal tersebut. Hal ini tidak terjadi dalam arsitektur microservice. Operator aplikasi yang menggunakan arsitektur microservice perlu mengatur banyak package aplikasi atau service. Komunikasi antar fungsionalitas yang awalnya terjadi di dalam aplikasi, berpindah menjadi diluar aplikasi melalui network.

Kubernetes hadir untuk menyelesaikan masalah operasional aplikasi berbasis microservice. Kubernetes masuk dalam teknologi bernama orchestrator. Teknologi ini fokus pada cara deployment dan operasional aplikasi dalam jumlah besar. Terdapat mplementasi teknologi orchestrator lainnya yaitu Nomad dan Docker Swarm. Kubernetes pada awalnya merupakan proyek internal Google yang kemudian dibuka sebagai open-source project.

Menggunakan Kubernetes

Pada artikel ini, saya akan mencoba menjalankan aplikasi sederhana berbasis Python yang saya gunakan pula pada bagian sebelumnya tentang container. Aplikasi akan saya deploy di Google Cloud menggunakan Google Kubernetes Engine.

1. Upload Container Image ke Container Registry

Sebelum melakukan deployment, Container Image yang sudah dibuat harus diletakkan disebuah registry. Container Registry adalah suatu tempat yang dapat menampung banyak container image serta versi pembaruannya. Container Registry dapat dibuat public atau private. Contoh Container Registry yang public, adalah Container Registry milik Docker yaitu Docker Hub. Banyak aplikasi basis seperti Nginx, Linux, dan Python yang dapat diunduh secara gratis dari sini.

Pada artikel ini, saya akan menggunakan private registry yang dibuat di Google Cloud bernama Google Artifact Registry (GAR). Registry ini dapat dibuat menjadi public, namun secara default akan dibuat secara private. Untuk membuat GAR, buka halaman Google Artifact Registry di console Google Cloud. Pastikan akun yang digunakan memiliki role Artifact Registry Administrator. Tanpa role tersebut, kita tidak akan bisa membuat registry.

Tombol create repository pada Artifact Registry

Saya membuat registry dengan nama “my-registry” di region Jakarta. Pastikan format yang dipilih adalah Docker karena kita akan membuat registry untuk container berbasis Docker. Artifact Registry juga bisa dibuat untuk menyimpan package lainnya seperti package npm untuk NodeJS, Maven untuk Java, dan Apt untuk Debian Linux. Jangan lupa pula untuk memilih mode standard untuk registry ini.

Setelah registry sudah dibuat, kita akan mengunggah container image ke registry. Jika menggunakan komputer lokal, pastikan sudah memiliki CLI Docker dan gcloud. Kemudian jalankan command berikut untuk meng-autentikasi komputer lokal dengan registry yang ada di Google Cloud. Jika menggunakan Cloud Shell, command ini tidak perlu dilakukan.

gcloud auth cofigure-docker

Kita perlu melakukan tagging pada Container Image yang telah kita buat. Tagging yang perlu kita sematkan pada Container Image menjadi semacam path untuk melakukan upload Image ke registry. Untuk mengetahui path registry kita, copy registry path seperti gambar dibawah.

Sebagai contoh, saya memiliki path registry sebagai berikut:

asia-southeast2-docker.pkg.dev/project-sandbox-357505/my-registry

Kemudian, kita gunakan path registry ini untuk men-tag Container Image yang kita miliki kemudian image di-push ke registry tersebut.

# Tag Container dengan path registry
docker tag $nama-container-image <path registry>/app-python:1.0

# Push Image ke registry
docker push <path registry>/app-python:1.0

Setelah proses push selesai, container image app-python versi 1.0 akan tersedia di Artifact Registry.

2. Membuat Kubernetes Cluster di Google Kubernetes Engine

Untuk menjalankan aplikasi menggunakan Kubernetes, kita harus memiliki Kubernetes Cluster. Kubernetes Cluster adalah sekumpulan komputer (cluster) yang di-manage oleh sebuah Kubernetes master sehingga membentuk sistem komputer yang terdistribusi. Kita dapat membuat Kubernetes Cluster di Google Cloud menggunakan Google Kuberentes Engine (GKE). Untuk melalukan ini, buka halaman GKE di console Google Cloud.

Pada demo kali ini, saya akan menggunakan Kubernetes Cluster dengan mode standard. Saya menamai cluster-nya “my-cluster” dan memilih zona jakarta-c untuk tempat cluster. Terdapat banyak sekali parameter konfigurasi yang dapat di-customize dalam membuat GKE cluster seperti jumlah node, network, jadwal maintenance, dan masih banyak lagi. GKE juga memiliki mode autopilot. Dalam mode ini pengguna tidak perlu melakukan manajemen cluster dan beberapa konfigurasi sudah dipilihkan oleh Google.

Pembuatan cluster akan berjalan sekitar 5 menit hingga selesai. Setelah selesai, akan muncul nama cluster pada halaman GKE.

Untuk menggunakan cluster ini, kita perlu memiliki CLI Kubernetes bernama kubectl dan juga credentials. Jika menggunakan komputer lokal, panduan untuk menginstal kubectl terdapat disini. Jika menggunakan Cloud Shell, tidak perlu melakukan instalasi kubectl lagi karena kubectl sudah ada di Cloud Shell.

Untuk memilik credential cluster, klik titik tiga di sebelah kanan informasi cluster dan klik connect. Copy command CLI-nya dan jalankan di terminal. gcloud akan secara otomatis membuat credentials yang diperlukan agar kita dapat tersambung dengan cluster. Untuk mengecek, jalankan command berikut untuk mengambil informasi cluster.

kubectl cluster-info

Jika cluster berhasil diakses, kubectl akan memberikan informasi nama komponen kubernetes dan alamat IP nya.

3. Membuat Manifest Aplikasi

Aplikasi tidak dapat langsung di-deploy di Kubernetes cluster. Kita harus membuat manifest aplikasi terlebih dulu. Manifest ini seperti konfigurasi deployment aplikasi yang memiliki informasi nama aplikasi, jumlah replika, environmet variables, dan lain-lain. Ada banyak hal yang bisa di-configure, namun dalam artikel ini, saya akan sangat menyederhanakannya dengan hanya menggunakan deployment dan service. 2 konfigurasi ini merupakan konfigurasi minimal agar aplikasi dapat diakses dari internet. Kubernetes memiliki banyak tipe konfigurasi lainnya yang dapat ditemukan disini.

Buat 2 file bernama deployment.yaml dan service.yaml dengan menyalin kode dibawah.

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloworld
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      containers:
      - name: hello-app
        image: <LOKASI CONTAINER IMAGE>
        ports:
        - containerPort: 8080
        env:
          - name: PORT
            value: "8080"

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: hello
spec:
  type: LoadBalancer
  selector:
    app: hello
  ports:
  - port: 80
    targetPort: 8080

Jangan lupa untuk mengubah <LOKASI CONTAINER IMAGE> dengan lokasi yang sudah dibuat di langkah pertama. deployment.yaml memberitahu kubernetes bahwa kita ingin menjalankan 1 replika container image dengan lokasi yang kita masukkan. service.yaml berisi informasi terkait service yang ingin kita expose agar dapat digunakan oleh orang lain baik melalui internet atau di dalam cluster.

Untuk menjalankan aplikasi, kita perlu men-submit kedua file ini ke cluster kita dengan command berikut:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Setelah selesai, kita dapat mengecek apakah aplikasi berjalan atau tidak dengan menjalankan command berikut:

kubectl get po

Command ini akan memberikan informasi pod apa saja yang sedang dijalankan di cluster. Pod merupakan unit terkecil aplikasi yang dapat dijalankan pada Kubernetes. Jika berhasil, maka akan terdapat informasi seperti ini.

Pada file service.yaml, kita memberitahu kubernetes bahwa service kita bertipe “Load Balancer”. Hal ini berarti GKE akan secara otomatis membuat External Load Balancer di Google Cloud sehingga service dapat diakses dari internet melalui IP publik dan beban aplikasi akan didistribusikan. Perlu beberapa waktu untuk membuat Load Balancer ini. Untuk melihat IP Load Balancer, buka halaman GKE dan pilih tab Services & Ingress.

Dibawah “Endpoints” terdapat IP yang dapat diklik yang akan mengarahkan kita ke aplikasi hello python.

Aplikasi hello-python berhasil dijalankan di Kubernetes

Kesimpulan

Menjalankan aplikasi microservice bisa menjadi sulit karena operator harus mengatur banyak aplikasi di banyak komputer. Kubernetes dibuat untuk membantu meringankan beban ini. Kubernetes merupakan platform yang dapat menjalankan aplikasi terdistribusi di banyak komputer. Kubernetes dapat dikonfigurasi dengan berbagai macam parameter dan variabel, namun untuk sekedar mencoba, kita bisa langsung menggunakan Google Kubernetes Engine.

Sekian, blog modernisasi aplikasi bagian 2 tentang kubernetes. Topik ini merupakan topik yang cukup luas dan tentunya tidak akan cukup untuk dibahas pada satu artikel saja. Satu hal yang belum dibahas adalah keamanan dalam kubernetes dan komunikasi antar service yang sangat banyak. Hal ini akan saya bahas di topik selanjutnya yaitu Service Mesh. Topik ini cukup menarik untuk dibahas karena hampir aplikasi besar menggunakan semacam proxy dan Service Mesh diatas Kubernetes untuk menambah kapabilitasnya. Stay tuned!

Jangan lupa berikan clap if you enjoy this ya!

Terimakasih dan salam sejahtera! 😊