Tutorial Kubernetes: Panduan Pemula untuk Mendeploy Aplikasi

Dasar Kubernetes: Pod, Deployment, Service, dan Namespace

Sekarang setelah kita menyiapkan klaster dan memeriksa semuanya berfungsi, saatnya membuat aplikasi pertama kita.

Namun sebelum membuat aplikasi pertama, penting untuk memahami dasar-dasar Kubernetes. Jika Anda menginginkan pengenalan Kubernetes yang lebih mendalam, saya sarankan Anda melihat kursus Introduction to Kubernetes.

Konsep paling dasar di Kubernetes adalah Pod, Deployment, dan Service. Mengetahui tiga jenis sumber daya ini dapat membantu Anda membuat aplikasi yang andal. Karena itu, mari kita bahas lebih dalam.

Apa itu Pod?

Pod adalah unit terkecil yang bisa dideploy di Kubernetes. Pod menjalankan satu atau beberapa kontainer yang terikat erat dengan penyimpanan, jaringan, dan namespace yang sama. Pod selalu dijadwalkan pada node Kubernetes. 

Anda dapat menentukan berapa banyak sumber daya yang harus didapatkan Pod Anda (misalnya CPU dan memori). 

Contoh aplikasi dengan dua kontainer bisa berupa kontainer aplikasi Anda dan kontainer pembantu yang mengumpulkan log dan mengirimkannya ke suatu tempat. 

Fitur sebuah Pod:

• Instans tunggal: Setiap Pod menjalankan satu instans aplikasi Anda.
• Bersifat efemeris: Pod dirancang sementara dan akan diganti jika gagal atau diperbarui.

Contoh YAML untuk membuat Pod:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    ports:
    - containerPort: 80

Anda kemudian dapat memasang Pod menggunakan kubectl:

kubectl apply -f pod.yaml

Ini akan memulai Pod bernama my-pod, yang menjalankan webserver nginx untuk Anda.

Apa itu Deployment?

Deployment adalah objek Kubernetes tingkat lebih tinggi yang digunakan untuk mengelola siklus hidup Pod. Deployment memastikan jumlah replika Pod yang diinginkan berjalan serta menangani pembaruan dan rollback. 

Fitur sebuah Deployment:

• Manajemen replika: Memastikan jumlah pod yang diinginkan selalu berjalan.
• Self-healing: Secara otomatis mengganti Pod yang tidak sehat.
• Rolling update: Memperbarui versi aplikasi secara bertahap tanpa downtime (jika dikonfigurasi).

Mari lihat bagaimana file YAML Deployment yang kembali membuat webserver nginx, tetapi kali ini dengan tiga replika:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80

Anda dapat memasang Deployment tersebut dengan kubectl:

kubectl apply -f deployment.yaml

Konfigurasi di atas akan membuat Deployment bernama nginx-deployment yang membuat tiga Pod, masing-masing menjalankan kontainer nginx. 

Apa itu Service?

Sekarang mari masuk ke bagian terakhir: Service. 

Service adalah abstraksi yang menyediakan akses jaringan stabil ke Pod, bahkan jika alamat IP-nya berubah. Service bertindak sebagai jembatan antara aplikasi Anda dan klien eksternal. 

Tetapi mengapa hal itu diperlukan? Setiap Pod memiliki alamat IP. Jadi mengapa kita tidak bisa langsung menggunakan alamat IP itu? 

Bisa! Namun sebaiknya tidak. Mengapa? 

Karena Pod bersifat efemeris, ia bisa dimatikan oleh Deployment, dan Pod baru akan diskalakan naik kapan pun Pod Anda tidak sehat. Pod baru ini akan memiliki alamat IP yang berbeda. Ini berarti klien yang ingin menggunakan aplikasi Anda harus terus-menerus mengubah alamat IP setiap kali Pod crash, yang bisa sering terjadi.

Di sinilah Service berperan: Service mencari semua Pod yang cocok dengan label tertentu dan secara otomatis merutekan trafik ke Pod tersebut. Jika sebuah Pod tidak sehat, Service berhenti mengirim trafik ke Pod itu. Dan jika Pod baru muncul, Service akan mulai mengirim trafik ke Pod baru. 

Service juga mendistribusikan trafik di antara semua replika Deployment Anda, yang luar biasa karena ini berarti Anda dapat membuat lebih banyak instans aplikasi untuk mendistribusikan trafik tanpa harus mengelolanya melalui logika aplikasi Anda.

Jenis-jenis Service:

• ClusterIP (default): Mengekspos Service di dalam klaster.
• NodePort: Mengekspos Service pada port yang dapat diakses dari luar klaster.
• LoadBalancer: Terintegrasi dengan penyedia cloud untuk mengekspos Service melalui load balancer.

Contoh YAML untuk mengekspos server web nginx kita ke luar klaster:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

Anda dapat kembali membuat service tersebut menggunakan kubectl:

kubectl apply -f service.yaml

Service ini sekarang akan mendistribusikan trafik masuk ke semua Pod dengan label app=nginx pada Port 80. 

Jika Anda menjalankan perintah describe pada Service yang baru dibuat, Anda akan melihat ada tiga endpoint, di mana setiap endpoint mewakili alamat IP Pod yang saat ini berjalan:

kubectl describe service nginx-service

Perintah di atas seharusnya mengembalikan sesuatu yang mirip dengan ini: 

Name:                     nginx-service
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=nginx
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.104.53.131
IPs:                      10.104.53.131
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  32256/TCP
Endpoints:                10.244.0.5:80,10.244.0.6:80,10.244.0.7:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

Hubungan antara Pod, Deployment, dan Service

Jadi, ringkasnya:

• Pod: Mewakili instans aplikasi individual.
• Deployment: Mengelola siklus hidup Pod dan memastikan Pod tetap sehat.
• Service: Menyediakan akses stabil ke Pod dan memungkinkan komunikasi eksternal atau internal.

Apa itu Namespace?

Namespace di Kubernetes memungkinkan Anda mengatur dan mengisolasi sumber daya dalam satu klaster. Anggap saja sebagai klaster virtual di dalam klaster fisik yang sama. 

Manfaat menggunakan Namespace:

• Pemisahan tanggung jawab: Tim atau aplikasi berbeda dapat beroperasi dalam namespace masing-masing tanpa memengaruhi yang lain. 
• Manajemen sumber daya: Anda bisa menetapkan kuota dan batas sumber daya untuk berbagai namespace.
• Keamanan dan kontrol akses: Kebijakan dapat ditegakkan pada tingkat namespace.

Secara default, Kubernetes hadir dengan beberapa namespace bawaan:

• default: Namespace default tempat sumber daya dibuat kecuali ditentukan lain
• kube-system: Digunakan untuk komponen internal Kubernetes (misalnya, API server, scheduler, dll.).
• kube-public: Namespace yang dapat dibaca publik.
• kube-node-lease: Digunakan untuk melacak heartbeat node.

Anda dapat membuat namespace menggunakan file YAML: 

apiVersion: v1
kind: Namespace
metadata:
  name: my-namespace

Simpan ke file bernama namespace.yaml dan terapkan menggunakan: 

kubectl apply -f namespace.yaml

Saat menjalankan perintah di bawah ini, Anda akan melihat daftar semua namespace default yang disebutkan dan yang baru dibuat: 

kubectl get namespaces

Anda kemudian dapat membuat sumber daya di namespace tersebut dengan cukup menetapkan namespace di bagian metadata sumber daya Anda. 

Deployment nginx kita akan terlihat seperti berikut jika kita ingin membuatnya di namespace yang baru Anda buat:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: my-namespace
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80

Sekarang, Anda perlu menyatakan secara eksplisit bahwa Anda ingin mengambil sumber daya dari namespace yang baru dibuat menggunakan argumen -n : 

kubectl get deployment -n my-namespace

Mengelola Aplikasi Pertama Anda dengan Kubernetes

Baik, sekarang setelah Anda familier dengan konsep dasar Kubernetes, saatnya mendeploy aplikasi web pertama kita ke Kubernetes dan mencoba mengaksesnya. 

Di bab ini, kita akan membuat server web nginx, mengekspos server web tersebut melalui Service ke dunia luar, melakukan scale pada aplikasi untuk mensimulasikan perilaku trafik tinggi, dan memperbarui aplikasi menggunakan rolling update ke versi yang lebih baru.

Jadi, mari mulai hal-hal yang menyenangkan!

Membuat deployment aplikasi web sederhana

Langkah pertama adalah membuat Deployment untuk webserver kita yang membuat kontainer menggunakan image Nginx.

Salin kode di bawah dan simpan ke file bernama nginx-deployment.yaml.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

Lalu, terapkan Deployment tersebut ke klaster Anda menggunakan perintah berikut:

kubectl apply -f nginx-deployment.yaml

Anda kemudian dapat memverifikasi bahwa Pod berjalan: 

kubectl get pods

Mengekspos aplikasi dengan service

Kita harus mengekspos server web nginx melalui Service ke dunia luar. Untuk ini, kita membuat Service tipe NodePort, karena kita ingin mengakses webserver nginx dari mesin lokal kita di luar klaster Kubernetes.

Jadi buat file bernama nginx-service.yaml dan tambahkan konten berikut:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

Anda kemudian dapat menerapkan Service dengan perintah di bawah ini:

kubectl apply -f nginx-service.yaml

Terakhir, Anda dapat menggunakan minikube untuk mendapatkan URL ke server web nginx Anda:

minikube service nginx-service --url

Buka URL tersebut di browser Anda, dan Anda akan melihat halaman sambutan dari server web nginx Anda.

Tangkapan layar halaman sambutan web server nginx di browser lokal.

Melakukan skala aplikasi

Jadi, kita memiliki satu Pod yang berjalan. Namun mungkin ada banyak pengguna yang mengunjungi halaman web kita. Inilah sebabnya, di Kubernetes, Anda dapat dengan cepat melakukan skala aplikasi agar lebih banyak Pod berjalan. 

Service akan secara otomatis mendeteksi semua Pod yang termasuk dalam Deployment tersebut dan kemudian melakukan load balancing permintaan masuk ke semua Pod yang menjalankan web server nginx. Ini membantu meningkatkan performa keseluruhan halaman web kita jika ada banyak trafik yang masuk.

Jadi, mari skala aplikasi kita menjadi 3 replika menggunakan perintah di bawah ini:

kubectl scale deployment nginx-deployment --replicas=3

Sekarang Anda dapat mengambil lagi semua Pod yang berjalan, yang seharusnya berjumlah tiga:

kubectl get pods

Anda juga dapat menggunakan perintah di bawah ini untuk mendapatkan semua endpoint tempat nginx-service kita terhubung. Ini seharusnya mengembalikan tiga endpoint, di mana setiap endpoint adalah alamat IP internal klaster masing-masing:

kubectl get endpoints nginx-service

Rolling update

Sekarang, kita memiliki manfaat besar lainnya dari menggunakan Kubernetes: Rolling update.

Tujuan rolling update adalah menghindari downtime pada aplikasi web Anda. Bayangkan kerugian finansial bagi perusahaan seperti Amazon jika halaman webnya down setiap kali Amazon merilis versi baru.

Dengan rolling update, Kubernetes melakukan scale up Pod baru, memeriksa apakah Pod tersebut sehat, lalu melakukan scale down Pod lama. 

Secara default, Kubernetes memastikan setidaknya 75% dari jumlah Pod yang diinginkan tetap berjalan, dengan 25% sebagai jumlah maksimum yang tidak tersedia. Ini berarti, untuk kasus kita dengan tiga replika yang berjalan, Kubernetes hanya akan menambahkan satu Pod baru pada satu waktu, memeriksa kesehatannya, dan menurunkan satu Pod lainnya jika sudah sehat. Proses ini akan diulang sampai semua Pod diperbarui ke versi baru.

Jadi mari kita lakukan dengan mengubah versi image nginx kita dari latest ke 1.23:

kubectl set image deployment/nginx-deployment nginx=nginx:1.23

Anda kemudian dapat memantau status rollout menggunakan: 

kubectl rollout status deployment/nginx-deployment

Keluaran akan terlihat mirip dengan: 

Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
deployment "nginx-deployment" successfully rolled out

Dan saat rollout berlangsung, halaman web Anda tetap dapat diakses sepanjang waktu tanpa downtime!

Bukankah itu hebat?

Mengelola Sumber Daya Kubernetes

Kubernetes menyediakan alat yang andal untuk memeriksa, memodifikasi, dan menghapus sumber daya dari semua jenis. Memahami cara mengelola sumber daya secara efektif memastikan pemecahan masalah yang lebih baik, alokasi sumber daya, dan pemeliharaan klaster secara keseluruhan. 

Di bagian ini, kita akan membahas perintah penting lainnya yang membantu Anda mengelola sumber daya secara efektif dan melakukan troubleshooting jika terjadi masalah.

Melihat sumber daya klaster

Sebelum mengubah sumber daya apa pun, penting untuk melihat dan memeriksa sumber daya yang saat ini berjalan di klaster Anda.

Anda dapat, misalnya, membuat daftar semua Pod, Service, dan Deployment yang berjalan untuk melihat apa yang terjadi di klaster Anda: 

# list running Pods
kubectl get pods

# list running Services 
kubectl get services

# list running Deployments
kubectl get deployments

Jika Anda ingin menggali lebih dalam ke sumber daya tertentu, Anda dapat menggunakan perintah describe :

kubectl describe deployment nginx-deployment

Ini akan menampilkan lebih banyak informasi, termasuk rolling update, skala, atau event penarikan image. Ini adalah titik awal yang dapat Anda tuju jika terjadi kesalahan.

Anda juga dapat memeriksa log dari Pod yang berjalan untuk melihat apa yang terjadi di dalam Pod tersebut menggunakan perintah di bawah ini:

kubectl logs <pod-name>

Menghapus sumber daya

Penting juga untuk membersihkan sumber daya jika tidak lagi digunakan untuk mengosongkan sumber daya klaster bagi aplikasi baru. 

Anda dapat menghapus Pod menggunakan:

kubectl delete pod <pod-name>

Kita dapat melakukan ini untuk salah satu pod nginx kita. Namun, sebuah Pod baru harus segera diskalakan naik, karena Pod dikelola melalui Deployment, yang selalu berupaya menjaga tiga replika berjalan. 

Jadi di sini, kita perlu menghapus nginx-deployment: 

kubectl delete deployment nginx-deployment

Setelah menjalankan perintah ini, semua Pod nginx yang berjalan harus terhapus. 

Kita juga bisa menghapus semua sumber daya di sebuah Namespace. Perintah berikut akan menghapus semua sumber daya kita, yang secara default dibuat di Namespace default :

kubectl delete all --all

Kesimpulan

Selamat! Anda telah mencapai akhir dan berhasil mengambil langkah pertama Anda di Kubernetes. 

Dengan mengikuti tutorial ini, Anda telah mempelajari cara:

• Menyiapkan klaster Kubernetes lokal menggunakan minikube.
• Bekerja dengan Pod, Deployment, Service, dan Namespace (blok pembangun esensial Kubernetes).
• Mendeploy dan mengelola aplikasi web sederhana di dalam Kubernetes.
• Melakukan skala aplikasi secara dinamis dan melakukan rolling update tanpa downtime.
• Mengelola sumber daya Kubernetes dengan membuat daftar, mendeskripsikan, dan menghapusnya.

Kubernetes pada awalnya bisa terasa kompleks (setidaknya bagi saya). Namun memecahnya menjadi konsep-konsep fundamental membuatnya lebih mudah didekati. 

Teruslah bereksperimen dan deploy lebih banyak aplikasi. 

Cara terbaik belajar Kubernetes adalah dengan praktik, jadi mulailah membangun!

Untuk lebih meningkatkan keterampilan Kubernetes Anda, pertimbangkan untuk mengeksplorasi:

• Bekerja dengan ConfigMap dan Secret: Menyimpan dan mengelola pengaturan konfigurasi secara aman.
• Persistent volume: Pelajari cara menyimpan data yang tetap ada setelah Pod restart menggunakan persistent volume.
• Jaringan dan ingress controller: Menyiapkan routing berbasis domain dan mengelola trafik eksternal.
• Helm: Gunakan chart Helm untuk mengemas dan mendeploy aplikasi kompleks secara efisien.
• Kubernetes di cloud: Bereksperimen dengan layanan Kubernetes terkelola seperti AWS EKS, Azure AKS, atau Google GKE.

Pada akhirnya, track Containerization and Virtualization with Docker and Kubernetes di DataCamp adalah sumber yang sangat baik untuk berlatih dengan Docker dan Kubernetes.