1~
2Jika 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.
3~
4## Sebelum Kubernetes: Sedikit Sejarah
5~
6Untuk memahami mengapa Kubernetes begitu revolusioner, mari kita mundur sejenak.
7~
81.  **Deployment Tradisional**: Awalnya, aplikasi dijalankan di server fisik. Pendekatan ini mahal, sulit diskalakan, dan rentan terhadap konflik sumber daya.
92.  **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.
103.  **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.
11~
12Kontainer 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?
13~
14Di sinilah **Kubernetes** berperan.
15~
16## Apa itu Kubernetes?
17~
18Kubernetes (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.
19~
20## Arsitektur Cluster Kubernetes
21~
22Lingkungan 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.
23~
24```mermaid
25graph TD
26    subgraph "Control Plane (Master)"
27        A["API Server"]
28        B["etcd"]
29        C["Scheduler"]
30        D["Controller Manager"]
31    end
32~
33    subgraph "Worker Node 1"
34        E["Kubelet"] --- F["Container Runtime"]
35        G["Kube-proxy"]
36        F --- H["Pod"]
37        F --- I["Pod"]
38    end
39~
40    subgraph "Worker Node 2"
41        J["Kubelet"] --- K["Container Runtime"]
42        L["Kube-proxy"]
43        K --- M["Pod"]
44    end
45~
46    A -- "Communicates with" --> E
47    A -- "Communicates with" --> J
48    User -- "kubectl" --> A
49    C -- "Assigns Pods to Nodes" --> E
50    D -- "Maintains state" --> A
51    A -- "Saves/Reads state" --> B
52```
53~
54### Control Plane
55~
56Control Plane adalah "otak" dari cluster. Ia membuat keputusan global (seperti penjadwalan) dan mendeteksi serta merespons event cluster. Komponen utamanya adalah:
57~
58-   **API Server (`kube-apiserver`)**: Gerbang ke cluster. Ia mengekspos API Kubernetes, yang digunakan oleh pengguna (melalui `kubectl`), komponen cluster, dan alat eksternal untuk berkomunikasi.
59-   **etcd**: Database key-value yang konsisten dan sangat tersedia. Ia menyimpan semua data cluster, merepresentasikan state yang diinginkan dan saat ini dari sistem.
60-   **Scheduler (`kube-scheduler`)**: Menetapkan Pods yang baru dibuat ke Worker Node yang tersedia, dengan mempertimbangkan kebutuhan sumber daya, kebijakan, dan batasan lainnya.
61-   **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.
62~
63### Worker Node
64~
65Worker Nodes adalah mesin (fisik atau virtual) di mana aplikasi benar-benar dijalankan. Setiap node dikelola oleh Control Plane dan berisi komponen berikut:
66~
67-   **Kubelet**: Agen yang berjalan di setiap node. Ia memastikan kontainer yang dijelaskan dalam Pods berjalan dan sehat.
68-   **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.
69-   **Container Runtime**: Perangkat lunak yang bertanggung jawab menjalankan kontainer. Docker paling terkenal, tetapi Kubernetes juga mendukung runtime lain seperti `containerd` dan `CRI-O`.
70~
71## Objek Fundamental Kubernetes
72~
73Di 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.
74~
75Berikut yang paling penting:
76~
77### Pod
78~
79**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.
80~
81Umumnya, Anda menjalankan hanya satu kontainer per Pod, tetapi dalam skenario lanjutan (seperti "sidecar containers" untuk logging atau monitoring), Anda bisa memiliki lebih banyak.
82~
83Anda hampir tidak pernah membuat Pods secara langsung. Anda menggunakan abstraksi tingkat lebih tinggi seperti Deployments.
84~
85### Deployment
86~
87**Deployment** adalah objek yang paling sering Anda gunakan. Ia menjelaskan state yang diinginkan untuk sekelompok Pods yang identik. Controller Deployment bertanggung jawab untuk:
88~
89-   Membuat dan mengelola **ReplicaSet** (objek lain yang memastikan jumlah replika Pod tertentu selalu berjalan).
90-   **Menskalakan** jumlah Pods ke atas atau ke bawah.
91-   Mengelola **pembaruan** aplikasi secara terkontrol (misalnya, *Rolling Update*), tanpa downtime.
92~
93Berikut contoh file YAML untuk Deployment yang menjalankan 3 replika server NGINX:
94~
95```yaml
96# nginx-deployment.yaml
97apiVersion: apps/v1
98kind: Deployment
99metadata:
100  name: nginx-deployment
101spec:
102  replicas: 3
103  selector:
104    matchLabels:
105      app: nginx
106  template:
107    metadata:
108      labels:
109        app: nginx
110    spec:
111      containers:
112      - name: nginx
113        image: nginx:1.14.2
114        ports:
115        - containerPort: 80
116```
117~
118### Service
119~
120Pods 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?
121~
122Dengan **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.
123~
124```mermaid
125graph TD
126    subgraph "Service (nginx-service)"
127        A["ClusterIP: 10.96.0.10"]
128    end
129~
130    subgraph "Pods"
131        B("Pod 1 - IP: 192.168.1.2")
132        C("Pod 2 - IP: 192.168.1.3")
133        D("Pod 3 - IP: 192.168.1.4")
134    end
135~
136    A -- "Selector: app=nginx" --> B
137    A -- "Selector: app=nginx" --> C
138    A -- "Selector: app=nginx" --> D
139~
140    Client -- "Request to nginx-service" --> A
141```
142~
143Service menggunakan `selector` berdasarkan `labels` untuk menemukan Pods yang harus menerima trafik.
144~
145Berikut cara membuat Service untuk Deployment NGINX kita:
146~
147```yaml
148# nginx-service.yaml
149apiVersion: v1
150kind: Service
151metadata:
152  name: nginx-service
153spec:
154  selector:
155    app: nginx
156  ports:
157    - protocol: TCP
158      port: 80
159      targetPort: 80
160  type: ClusterIP # Default - exposes the service only within the cluster
161```
162~
163Ada berbagai jenis Services:
164- `ClusterIP`: Mengekspos service pada IP internal cluster (default).
165- `NodePort`: Mengekspos service pada port statis di setiap Worker Node.
166- `LoadBalancer`: Membuat load balancer eksternal di cloud provider (misalnya, AWS, GCP) dan menetapkan IP publik ke service.
167~
168### Ingress
169~
170Service `LoadBalancer` memang bagus, tetapi membuat satu untuk setiap service bisa mahal. Untuk mengekspos beberapa service HTTP/HTTPS ke dunia luar, Anda menggunakan **Ingress**.
171~
172Ingress 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`).
173~
174```mermaid
175graph LR
176    User -- "mysite.com/api" --> Ingress
177    User -- "mysite.com/ui" --> Ingress
178~
179    subgraph "Cluster"
180        Ingress -- "/api" --> ServiceA("api-service")
181        Ingress -- "/ui" --> ServiceB("ui-service")
182~
183        ServiceA --> PodA1("API Pod 1")
184        ServiceA --> PodA2("API Pod 2")
185~
186        ServiceB --> PodB1("UI Pod 1")
187        ServiceB --> PodB2("UI Pod 2")
188    end
189```
190~
191Berikut contoh Ingress:
192```yaml
193# example-ingress.yaml
194apiVersion: networking.k8s.io/v1
195kind: Ingress
196metadata:
197  name: example-ingress
198spec:
199  rules:
200  - host: mysite.com
201    http:
202      paths:
203      - path: /api
204        pathType: Prefix
205        backend:
206          service:
207            name: api-service
208            port:
209              number: 8080
210      - path: /ui
211        pathType: Prefix
212        backend:
213          service:
214            name: ui-service
215            port:
216              number: 3000
217```
218~
219### Objek Berguna Lainnya
220~
221-   **Namespace**: Memungkinkan Anda membuat "cluster virtual" di dalam cluster fisik. Berguna untuk mengisolasi lingkungan (misalnya, `development`, `staging`, `production`) atau tim.
222-   **ConfigMap dan Secret**: Untuk mengelola data konfigurasi dan rahasia (seperti password atau API key) yang dipisahkan dari image kontainer.
223-   **StatefulSet**: Mirip dengan Deployment, tetapi khusus untuk aplikasi stateful (seperti database) yang memerlukan identitas jaringan stabil dan penyimpanan persisten.
224-   **PersistentVolume (PV) dan PersistentVolumeClaim (PVC)**: Untuk mengelola penyimpanan persisten di cluster.
225~
226## Kesimpulan
227~
228Kubernetes 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.
229~
230**Apa yang harus dilakukan sekarang?**
231- **Eksperimen secara lokal**: Instal [Minikube](https://minikube.sigs.k8s.io/docs/start/) atau [Kind](https://kind.sigs.k8s.io/docs/user/quick-start/) untuk membuat cluster Kubernetes di komputer Anda.
232- **Gunakan `kubectl`**: Biasakan diri dengan perintah `kubectl`, alat utama Anda untuk berinteraksi dengan cluster. Coba buat Deployment dan Service NGINX dari artikel ini.
233- **Jelajahi tutorial resmi**: [Dokumentasi Kubernetes](https://kubernetes.io/docs/tutorials/) adalah sumber yang fantastis penuh dengan contoh.
234~
235Orkestrasi kontainer adalah keterampilan fundamental di dunia cloud-native, dan menguasai Kubernetes akan membuka dunia kemungkinan. Selamat bersenang-senang!
236~