Pengantar Kubernetes: Orkestrator Kontainer

Jika Anda bekerja di dunia pengembangan perangkat lunak, Anda pasti pernah mendengar tentang Kubernetes. Tapi apa sebenarnya Kubernetes, dan mengapa ia menjadi standar de facto untuk mengelola aplikasi yang dikontainerisasi? Panduan ini akan membawa Anda dari dasar hingga konsep fundamental, dengan contoh praktis dan diagram untuk membantu pemahaman.

Sebelum Kubernetes: Sedikit Sejarah

Untuk memahami mengapa Kubernetes begitu revolusioner, mari kita mundur sejenak.

1. Deployment Tradisional: Awalnya, aplikasi dijalankan di server fisik. Pendekatan ini mahal, sulit diskalakan, dan rentan terhadap konflik sumber daya.
2. Deployment Tervirtualisasi: Kemudian muncul Virtual Machine (VM). VM memungkinkan menjalankan beberapa aplikasi terisolasi pada hardware yang sama, meningkatkan pemanfaatan sumber daya dan keamanan. Namun, setiap VM menjalankan sistem operasi lengkap, mengonsumsi banyak sumber daya.
3. Deployment Terkontainerisasi: Kontainer (seperti Docker) adalah evolusi berikutnya. Mereka berbagi sistem operasi host yang sama tetapi menjalankan proses terisolasi. Mereka ringan, cepat untuk dimulai, dan portabel.

Kontainer memecahkan masalah portabilitas tetapi menciptakan masalah lain: bagaimana mengelola ratusan (atau ribuan) kontainer di lingkungan produksi? Bagaimana memastikan mereka selalu berjalan, dapat berkomunikasi satu sama lain, dan menskalakan berdasarkan beban?

Di sinilah Kubernetes berperan.

Apa itu Kubernetes?

Kubernetes (sering disingkat K8s) adalah platform open-source untuk orkestrasi kontainer. Secara sederhana, ia mengotomatisasi deployment, penskalaan, dan pengelolaan aplikasi yang dikontainerisasi. Dibuat oleh Google dan sekarang dikelola oleh Cloud Native Computing Foundation (CNCF), Kubernetes telah menjadi alat utama bagi siapa saja yang bekerja dengan microservices dalam skala besar.

Arsitektur Cluster Kubernetes

Lingkungan Kubernetes disebut cluster. Cluster terdiri dari sekumpulan mesin, yang disebut nodes, yang menjalankan aplikasi kita. Arsitekturnya dibagi menjadi dua bagian utama: Control Plane dan Worker Nodes.

Control Plane

Control Plane adalah "otak" dari cluster. Ia membuat keputusan global (seperti penjadwalan) dan mendeteksi serta merespons event cluster. Komponen utamanya adalah:

• API Server (kube-apiserver): Gerbang ke cluster. Ia mengekspos API Kubernetes, yang digunakan oleh pengguna (melalui kubectl), komponen cluster, dan alat eksternal untuk berkomunikasi.
• etcd: Database key-value yang konsisten dan sangat tersedia. Ia menyimpan semua data cluster, merepresentasikan state yang diinginkan dan saat ini dari sistem.
• Scheduler (kube-scheduler): Menetapkan Pods yang baru dibuat ke Worker Node yang tersedia, dengan mempertimbangkan kebutuhan sumber daya, kebijakan, dan batasan lainnya.
• Controller Manager (kube-controller-manager): Menjalankan controller, yaitu loop kontrol yang memantau state cluster dan bekerja untuk membawanya ke state yang diinginkan. Misalnya, Node Controller mengelola nodes, sementara Replication Controller memastikan jumlah Pods yang benar berjalan.

Worker Node

Worker Nodes adalah mesin (fisik atau virtual) di mana aplikasi benar-benar dijalankan. Setiap node dikelola oleh Control Plane dan berisi komponen berikut:

• Kubelet: Agen yang berjalan di setiap node. Ia memastikan kontainer yang dijelaskan dalam Pods berjalan dan sehat.
• Kube-proxy: Proxy jaringan yang mengelola aturan jaringan pada nodes. Ia memungkinkan komunikasi jaringan ke Pods dari sesi jaringan di dalam atau di luar cluster.
• Container Runtime: Perangkat lunak yang bertanggung jawab menjalankan kontainer. Docker paling terkenal, tetapi Kubernetes juga mendukung runtime lain seperti containerd dan CRI-O.

Objek Fundamental Kubernetes

Di Kubernetes, semuanya direpresentasikan oleh objek. Objek-objek ini adalah "catatan niat": setelah Anda membuat objek, Kubernetes terus bekerja untuk memastikan ia ada dan sesuai dengan state yang diinginkan.

Berikut yang paling penting:

Pod

Pod adalah unit eksekusi terkecil di Kubernetes. Ia merepresentasikan satu atau lebih kontainer yang dijalankan bersama di node yang sama, berbagi sumber daya seperti jaringan dan penyimpanan.

Umumnya, Anda menjalankan hanya satu kontainer per Pod, tetapi dalam skenario lanjutan (seperti "sidecar containers" untuk logging atau monitoring), Anda bisa memiliki lebih banyak.

Anda hampir tidak pernah membuat Pods secara langsung. Anda menggunakan abstraksi tingkat lebih tinggi seperti Deployments.

Deployment

Deployment adalah objek yang paling sering Anda gunakan. Ia menjelaskan state yang diinginkan untuk sekelompok Pods yang identik. Controller Deployment bertanggung jawab untuk:

• Membuat dan mengelola ReplicaSet (objek lain yang memastikan jumlah replika Pod tertentu selalu berjalan).
• Menskalakan jumlah Pods ke atas atau ke bawah.
• Mengelola pembaruan aplikasi secara terkontrol (misalnya, Rolling Update), tanpa downtime.

Berikut contoh file YAML untuk Deployment yang menjalankan 3 replika server NGINX:

# nginx-deployment.yaml
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.14.2
        ports:
        - containerPort: 80

Service

Pods di Kubernetes bersifat sementara: mereka dapat dibuat dan dihancurkan kapan saja. Setiap Pod memiliki alamat IP sendiri, tetapi IP ini tidak stabil. Jadi, bagaimana kita mengekspos aplikasi kita secara andal?

Dengan Service. Service adalah abstraksi yang mendefinisikan sekumpulan Pods secara logis dan kebijakan untuk mengaksesnya. Ia menyediakan titik akses yang stabil (alamat IP virtual dan nama DNS) untuk sekelompok Pods.

Service menggunakan selector berdasarkan labels untuk menemukan Pods yang harus menerima trafik.

Berikut cara membuat Service untuk Deployment NGINX kita:

# nginx-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP # Default - exposes the service only within the cluster

Ada berbagai jenis Services:

• ClusterIP: Mengekspos service pada IP internal cluster (default).
• NodePort: Mengekspos service pada port statis di setiap Worker Node.
• LoadBalancer: Membuat load balancer eksternal di cloud provider (misalnya, AWS, GCP) dan menetapkan IP publik ke service.

Ingress

Service LoadBalancer memang bagus, tetapi membuat satu untuk setiap service bisa mahal. Untuk mengekspos beberapa service HTTP/HTTPS ke dunia luar, Anda menggunakan Ingress.

Ingress bertindak sebagai "router cerdas" untuk trafik eksternal. Ia memungkinkan Anda mendefinisikan aturan routing berdasarkan host (misalnya, api.mysite.com) atau path (misalnya, mysite.com/api).

Berikut contoh Ingress:

# example-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
spec:
  rules:
  - host: mysite.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 8080
      - path: /ui
        pathType: Prefix
        backend:
          service:
            name: ui-service
            port:
              number: 3000

Objek Berguna Lainnya

• Namespace: Memungkinkan Anda membuat "cluster virtual" di dalam cluster fisik. Berguna untuk mengisolasi lingkungan (misalnya, development, staging, production) atau tim.
• ConfigMap dan Secret: Untuk mengelola data konfigurasi dan rahasia (seperti password atau API key) yang dipisahkan dari image kontainer.
• StatefulSet: Mirip dengan Deployment, tetapi khusus untuk aplikasi stateful (seperti database) yang memerlukan identitas jaringan stabil dan penyimpanan persisten.
• PersistentVolume (PV) dan PersistentVolumeClaim (PVC): Untuk mengelola penyimpanan persisten di cluster.

Kesimpulan

Kubernetes adalah alat yang sangat powerful, tetapi kurva belajarnya bisa curam. Panduan ini baru menggores permukaannya, tetapi kami harap telah memberikan Anda pemahaman yang solid tentang konsep dasar.

Apa yang harus dilakukan sekarang?

• Eksperimen secara lokal: Instal Minikube atau Kind untuk membuat cluster Kubernetes di komputer Anda.
• Gunakan kubectl: Biasakan diri dengan perintah kubectl, alat utama Anda untuk berinteraksi dengan cluster. Coba buat Deployment dan Service NGINX dari artikel ini.
• Jelajahi tutorial resmi: Dokumentasi Kubernetes adalah sumber yang fantastis penuh dengan contoh.

Orkestrasi kontainer adalah keterampilan fundamental di dunia cloud-native, dan menguasai Kubernetes akan membuka dunia kemungkinan. Selamat bersenang-senang!