<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by mahendrarendi on Medium]]></title>
        <description><![CDATA[Stories by mahendrarendi on Medium]]></description>
        <link>https://medium.com/@rendinicolasm?source=rss-f5e3249994ac------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Jh7cXEx_AM-nnyUr</url>
            <title>Stories by mahendrarendi on Medium</title>
            <link>https://medium.com/@rendinicolasm?source=rss-f5e3249994ac------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 09:57:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rendinicolasm/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Serverless Application: Mengenal Arsitektur Serverless di Kubernetes dengan Knative]]></title>
            <link>https://medium.com/@rendinicolasm/serverless-application-mengenal-arsitektur-serverless-di-kubernetes-dengan-knative-c5ec87d20d7a?source=rss-f5e3249994ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/c5ec87d20d7a</guid>
            <category><![CDATA[serverless-architecture]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[knative]]></category>
            <dc:creator><![CDATA[mahendrarendi]]></dc:creator>
            <pubDate>Sun, 15 Nov 2026 15:29:24 GMT</pubDate>
            <atom:updated>2026-11-15T15:29:24.319Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DIM56lt-hE8FW9Xo-OAAnA.png" /></figure><h3>Apa itu serverless di Kubernetes?</h3><p><em>Serverless</em> bukan berarti aplikasi berjalan tanpa server. Dalam pendekatan ini, pengembang dapat lebih fokus membangun aplikasi, sementara platform menangani pengelolaan server dan menyesuaikan kapasitas sesuai kebutuhan (<a href="https://knative.dev/docs/serving/">Knative Serving</a>).</p><p>Pada Kubernetes, Pod biasanya tetap aktif meskipun aplikasi tidak menerima permintaan. Untuk aplikasi yang hanya sesekali digunakan, kondisi ini membuat sumber daya tetap terpakai saat aplikasi sedang idle (<a href="https://kubernetes.io/docs/concepts/workloads/controllers/deployment/">Kubernetes Deployment</a>).</p><p>Knative membantu menyesuaikan jumlah Pod dengan permintaan yang masuk, bahkan menurunkannya hingga nol ketika aplikasi tidak digunakan. Knative bekerja sebagai lapisan tambahan di atas Kubernetes, sehingga Kubernetes tetap menjadi fondasinya (<a href="https://knative.dev/docs/serving/autoscaling/">Knative Autoscaling</a>) .</p><h3>Asitektur Knative</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FhMe_SLjzYzkms7gqVpSMA.png" /><figcaption>Gambar 1. Knative Architecture</figcaption></figure><h4>Komponen Knative Serving</h4><p>Ketika kita membuat sebuah Knative Service, Knative mengelola beberapa resource yang saling berhubungan (<a href="https://knative.dev/docs/serving/services/">Knative Services</a>):</p><ul><li><strong>Service</strong> (sering disingkat ksvc): objek yang kita tulis. Satu manifest ini mewakili seluruh aplikasi (<a href="https://knative.dev/docs/serving/services/">Knative Services</a>).</li><li><strong>Configuration</strong>: menyimpan template aplikasi (image, env, dan sebagainya). Setiap kali template berubah, Configuration membuat Revision baru (<a href="https://knative.dev/docs/serving/services/">Knative Services</a>).</li><li><strong>Revision</strong>: snapshot aplikasi yang tidak bisa diubah. Setiap Revision didukung oleh sebuah Deployment (<a href="https://knative.dev/docs/serving/services/">Knative Services</a>).</li><li><strong>Route</strong>: mengatur ke Revision mana traffic diarahkan, termasuk pembagian persentase (<a href="https://knative.dev/docs/serving/traffic-management/">Knative Traffic Management</a>).</li></ul><p>Dengan demikian, satu manifest Service dapat menghasilkan Configuration, Revision, Route, dan Deployment yang diperlukan untuk menjalankan aplikasi. Perubahan pada konfigurasi aplikasi dapat menghasilkan Revision baru, dan setiap Revision didukung oleh sebuah Deployment (<a href="https://knative.dev/docs/serving/services/">Knative Services</a>; <a href="https://knative.dev/docs/serving/architecture/">Knative Serving Architecture</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xr2ONYFbizLdtbNnFqAaoA.png" /><figcaption><em>Gambar 2. Correlation about Knative Objects.</em></figcaption></figure><p><strong>Networking layer</strong></p><p>Knative membutuhkan layer ingress untuk menerima request dari luar. Pilihannya antara lain <strong>Kourier</strong> (ringan, berbasis Envoy, dibuat khusus untuk Knative), <strong>Istio</strong>, dan <strong>Contour</strong>. Ada juga integrasi dengan Gateway API. Di artikel ini saya memakai Kourier karena paling sederhana dan fokus kita tetap pada konsep Knative (<a href="https://knative.dev/docs/serving/architecture/">Knative Serving Architecture</a>; <a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>).</p><p><strong>Alur request</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wb__-obu3MFG4TcWIg_xXA.png" /><figcaption>Gambar 3. Request Flow Knative Serving</figcaption></figure><p>Pada lingkungan praktikum, gambaran sederhana alurnya adalah sebagai berikut (<a href="https://knative.dev/docs/serving/request-flow/">Knative Request Flow</a>; <a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>):</p><ul><li><strong>Kourier</strong> menerima request dan meneruskannya berdasarkan header Host. Inilah alasan setiap aplikasi Knative punya hostname sendiri (<a href="https://knative.dev/docs/serving/architecture/">Knative Serving Architecture</a>).</li><li><strong>Activator</strong> berada di jalur request saat Revision sedang nol Pod atau kapasitasnya rendah. Ia menahan request, memberi tahu Autoscaler agar menyalakan Pod, lalu meneruskan request setelah Pod siap. Pada kondisi normal dengan kapasitas cukup, request bisa langsung menuju Pod (<a href="https://knative.dev/docs/serving/request-flow/">Knative Request Flow</a>).</li><li><strong>Queue-Proxy</strong> adalah sidecar di setiap Pod. Ia menghitung request yang sedang berjalan (concurrency), membatasi jumlahnya, dan mengirim metrik ke Autoscaler (<a href="https://knative.dev/docs/serving/architecture/">Knative Serving Architecture</a>).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kG7Lqh5yC0Dyy86FAouOTw.png" /><figcaption>Gambar 4. <em>Request flow without activator.</em></figcaption></figure><p><strong>Autoscaler</strong></p><p>Knative Pod Autoscaler (KPA) menyesuaikan jumlah Pod berdasarkan permintaan yang diterima. KPA dapat menggunakan metrik <em>concurrency</em>, yaitu jumlah permintaan yang diproses bersamaan, atau <em>requests per second</em> (RPS). Target <em>concurrency</em> bawaan dapat diubah sesuai kebutuhan aplikasi (<a href="https://knative.dev/docs/serving/autoscaling/">Knative Autoscaling</a>; <a href="https://knative.dev/docs/serving/autoscaling/autoscaling-metrics/">Knative Autoscaling Metrics</a>; <a href="https://knative.dev/docs/serving/autoscaling/concurrency/">Knative Concurrency</a>).</p><p>KPA juga mendukung <em>scale-to-zero</em>: jumlah Pod dapat turun menjadi nol saat tidak ada permintaan, lalu bertambah kembali ketika permintaan datang (<a href="https://knative.dev/docs/serving/autoscaling/scale-to-zero/">Knative Scale to Zero</a>).</p><p><strong>Knative Eventing</strong></p><p>Selain Serving, Knative memiliki Eventing untuk aplikasi berbasis peristiwa. Secara sederhana, Source menghasilkan peristiwa, Broker menerimanya, dan Trigger dapat menyaring serta meneruskannya ke tujuan. Eventing tidak menjadi bagian dari pengujian pada artikel ini (<a href="https://knative.dev/docs/eventing/sources/">Knative Event Sources</a>; <a href="https://knative.dev/docs/eventing/triggers/">Knative Triggers</a>).</p><h3>Persiapan lab</h3><p>Sebelum memulai praktik, pastikan lingkungan berikut tersedia:</p><ol><li>Cluster Kubernetes yang dapat diakses melalui kubectl. Pada praktikum ini, cluster yang digunakan menjalankan Kubernetes v1.36.0 (<a href="https://github.com/mahendrarendi/knative-serving">lingkungan praktikum</a>).</li><li>Knative Serving dan Kourier sudah terpasang, serta komponen yang diperlukan berjalan. Versi Knative perlu mengikuti versi Kubernetes yang didukung (<a href="https://knative.dev/docs/install/serving/install-serving-with-yaml/">panduan instalasi Knative Serving</a>).</li><li>Konfigurasi jaringan Knative memilih Kourier sebagai <em>ingress class</em> (<a href="https://knative.dev/docs/install/serving/install-serving-with-yaml/">panduan instalasi Knative Serving</a>; <a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>).</li><li>Akses dashboard dari luar cluster tersedia melalui NGINX Gateway, HTTPRoute, DNS, dan sertifikat HTTPS (<a href="https://gateway-api.sigs.k8s.io/reference/api-types/httproute/">Gateway API HTTPRoute</a>; <a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>).</li><li>Image aplikasi ghcr.io/mahendrarendi/lambda-serverless dapat ditarik oleh cluster (<a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>).</li></ol><p>Dengan prasyarat tersebut, bagian berikutnya berfokus pada penerapan aplikasi dan pengamatan hasil dari setiap skenario.</p><h4>Praktik: Mengamati behaviour serverless application</h4><p>Pada bagian ini, kita menggunakan aplikasi Python sederhana untuk melihat bagaimana Knative merespons permintaan. Kode aplikasi dan panduan menjalankan lab tersedia di <a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>. Setelah lingkungan siap, pengujian dapat dilakukan melalui dashboard tanpa harus menjalankan setiap skenario dari terminal (<a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>).</p><p><strong>Langkah 1 — Jalankan aplikasi</strong></p><p>Mulailah dengan mengikuti panduan pada repository untuk menjalankan aplikasi di cluster. Aplikasi ini akan menjawab permintaan dengan menampilkan versi dan nama Pod yang melayaninya. Informasi sederhana tersebut akan membantu kita mengenali perubahan Pod dan versi aplikasi pada langkah berikutnya (<a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>).</p><p><strong>Langkah 2 — Lihat resource yang terbentuk</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2wd1q9NSpkOgIAn8i_W5Lw.png" /><figcaption><em>Gambar 5. Knative Service, Configuration, Revision, Route, and Deployment.</em></figcaption></figure><p>Setelah aplikasi berjalan, amati resource yang dikelola Knative. Dari satu Knative Service, kita dapat melihat Configuration, Revision, dan Route yang berkaitan dengan aplikasi, serta Deployment yang menjalankan Pod. Bagian ini menunjukkan bagaimana Knative mengelola aplikasi di atas resource Kubernetes (<a href="https://knative.dev/docs/serving/services/">Knative Services</a>; <a href="https://knative.dev/docs/serving/architecture/">Knative Serving Architecture</a>).</p><pre>root@cntrl1ab01:~# kubectl -n knative-lab get ksvc,configuration,revision,route,deploy,pods<br>NAME                                    URL                                              LATESTCREATED     LATESTREADY       READY   REASON<br>service.serving.knative.dev/autoscale   http://autoscale.knative-lab.svc.cluster.local   autoscale-00002   autoscale-00002   True<br>service.serving.knative.dev/coldstart   http://coldstart.knative-lab.svc.cluster.local   coldstart-00001   coldstart-00001   True<br>service.serving.knative.dev/hello       http://hello.lambda.mahendrarendi.cloud          hello-v2          hello-v2          True<br>service.serving.knative.dev/traffic     http://traffic.knative-lab.svc.cluster.local     traffic-v2        traffic-v2        True<br><br>NAME                                          LATESTCREATED     LATESTREADY       READY   REASON<br>configuration.serving.knative.dev/autoscale   autoscale-00002   autoscale-00002   True<br>configuration.serving.knative.dev/coldstart   coldstart-00001   coldstart-00001   True<br>configuration.serving.knative.dev/hello       hello-v2          hello-v2          True<br>configuration.serving.knative.dev/traffic     traffic-v2        traffic-v2        True<br><br>NAME                                           CONFIG NAME   GENERATION   READY   REASON   ACTUAL REPLICAS   DESIRED REPLICAS<br>revision.serving.knative.dev/autoscale-00001   autoscale     1            True             0                 0<br>revision.serving.knative.dev/autoscale-00002   autoscale     2            True             0                 0<br>revision.serving.knative.dev/coldstart-00001   coldstart     1            True             0                 0<br>revision.serving.knative.dev/hello-v1          hello         1            True             0                 0<br>revision.serving.knative.dev/hello-v2          hello         2            True             0                 0<br>revision.serving.knative.dev/traffic-v1        traffic       1            True             0                 0<br>revision.serving.knative.dev/traffic-v2        traffic       2            True             0                 0<br><br>NAME                                  URL                                              READY   REASON<br>route.serving.knative.dev/autoscale   http://autoscale.knative-lab.svc.cluster.local   True<br>route.serving.knative.dev/coldstart   http://coldstart.knative-lab.svc.cluster.local   True<br>route.serving.knative.dev/hello       http://hello.lambda.mahendrarendi.cloud          True<br>route.serving.knative.dev/traffic     http://traffic.knative-lab.svc.cluster.local     True<br><br>NAME                                         READY   UP-TO-DATE   AVAILABLE   AGE<br>deployment.apps/autoscale-00001-deployment   0/0     0            0           10h<br>deployment.apps/autoscale-00002-deployment   0/0     0            0           9h<br>deployment.apps/coldstart-00001-deployment   0/0     0            0           9h<br>deployment.apps/hello-v1-deployment          0/0     0            0           28h<br>deployment.apps/hello-v2-deployment          0/0     0            0           10h<br>deployment.apps/lab-dashboard                1/1     1            1           9h<br>deployment.apps/traffic-v1-deployment        0/0     0            0           9h<br>deployment.apps/traffic-v2-deployment        0/0     0            0           9h<br><br>NAME                                 READY   STATUS    RESTARTS   AGE<br>pod/lab-dashboard-6f9d7db474-pk5rd   1/1     Running   0          5h59m<br>root@cntrl1ab01:~#</pre><p><strong>Langkah 3 — Amati aplikasi saat tidak digunakan</strong></p><p>Buka skenario <strong>Cold start</strong> pada dashboard. Ketika tidak ada permintaan selama beberapa waktu, jumlah Pod dapat turun hingga nol. Tekan <strong>Send one request</strong>, lalu amati Pod muncul kembali dan melayani permintaan. Bandingkan waktu respons tersebut dengan permintaan berikutnya saat Pod sudah aktif (<a href="https://knative.dev/docs/serving/autoscaling/scale-to-zero/">Knative Scale to Zero</a>; <a href="https://knative.dev/docs/serving/request-flow/">Knative Request Flow</a>; <a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>).</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FTm_PretfrAc%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DTm_PretfrAc&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FTm_PretfrAc%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/bbaea2f70d13385418020b286ad92138/href">https://medium.com/media/bbaea2f70d13385418020b286ad92138/href</a></iframe><p><strong>Langkah 4 — Kirim banyak permintaan</strong></p><p>Pada skenario <strong>Autoscaling</strong>, tekan <strong>Start load test</strong>. Dashboard akan mengirim permintaan secara bersamaan. Amati jumlah Pod bertambah selama pengujian, lalu berkurang kembali setelah trafik berhenti. Perubahan ini memperlihatkan cara Knative menyesuaikan kapasitas aplikasi dengan beban yang diterima (<a href="https://knative.dev/docs/serving/autoscaling/">Knative Autoscaling</a>; <a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>).</p><iframe src="https://cdn.embedly.com/widgets/media.html?url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D0SLrb-Smabg&amp;type=text%2Fhtml&amp;schema=youtube&amp;display_name=YouTube&amp;src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F0SLrb-Smabg%3Ffeature%3Doembed" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/e82f8a4d166a1f1a339e862dcb8e86a4/href">https://medium.com/media/e82f8a4d166a1f1a339e862dcb8e86a4/href</a></iframe><p><strong>Langkah 5 — Bagi trafik ke dua versi</strong></p><p>Terakhir, buka skenario <strong>Traffic split</strong> dan tekan <strong>Send 100 requests</strong>. Aplikasi telah disiapkan dengan dua Revision: traffic-v1 menerima target 90% trafik dan traffic-v2 menerima 10%. Bandingkan target tersebut dengan jumlah respons dari masing-masing versi. Hasil dari 100 permintaan mungkin tidak tepat 90 dan 10 karena merupakan sampel pengujian (<a href="https://knative.dev/docs/serving/traffic-management/">Knative Traffic Management</a>; <a href="https://github.com/mahendrarendi/knative-serving">repository praktikum</a>).</p><iframe src="https://cdn.embedly.com/widgets/media.html?url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DAiLaDkB5lE4&amp;type=text%2Fhtml&amp;schema=youtube&amp;display_name=YouTube&amp;src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FAiLaDkB5lE4%3Ffeature%3Doembed" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/7ac4b61eb71e9fbad73ec3b5455722f3/href">https://medium.com/media/7ac4b61eb71e9fbad73ec3b5455722f3/href</a></iframe><h3>Kapan serverless cocok digunakan?</h3><p>Knative Serving cocok untuk aplikasi atau API yang trafiknya berubah-ubah. Saat sepi, jumlah Pod dapat turun hingga nol sehingga sumber daya tidak terus terpakai. Saat permintaan kembali datang, Knative menjalankan Pod untuk melayaninya. Fitur Revision dan Route juga memudahkan pengujian versi baru dengan mengalihkan sebagian kecil trafik terlebih dahulu (<a href="https://knative.dev/docs/serving/autoscaling/">Knative Autoscaling</a>; <a href="https://knative.dev/docs/serving/traffic-management/">Knative Traffic Management</a>).</p><p>Hal yang perlu dipertimbangkan adalah <strong>cold start</strong>, yaitu waktu yang diperlukan untuk menjalankan Pod setelah aplikasi berada pada nol replika. Karena itu, <em>scale-to-zero</em> kurang sesuai untuk aplikasi yang harus selalu merespons dengan sangat cepat. Aplikasi yang menjalankan proses terus-menerus atau menyimpan data hanya di dalam Pod juga memerlukan desain yang berbeda (<a href="https://kubernetes.io/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale/">Kubernetes Horizontal Pod Autoscaling</a>; <a href="https://kubernetes.io/blog/2026/09/02/kubernetes-v1-37-hpa-scale-to-zero-beta/">Kubernetes: HPA Scale to Zero</a>; <a href="https://knative.dev/docs/serving/request-flow/">Knative Request Flow</a>).</p><p>Deployment dengan HPA juga dapat menyesuaikan jumlah replika. Untuk layanan HTTP pada praktikum ini, perbedaan yang terlihat adalah Knative dapat menahan permintaan sementara Pod diaktifkan kembali dari nol (<a href="https://kubernetes.io/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale/">Horizontal Pod Autoscaling</a>; <a href="https://knative.dev/docs/serving/request-flow/">Knative request flow</a>)</p><h3>Ringkasan</h3><p>Praktikum ini memperlihatkan tiga kemampuan Knative Serving: menurunkan jumlah Pod hingga nol saat aplikasi idle, menambah Pod ketika beban meningkat, dan membagi trafik ke dua Revision. Dashboard membantu melihat perubahan resource yang terjadi setelah setiap pengujian.</p><p>Saat mencatat hasil, sertakan jumlah Pod, waktu respons, jumlah permintaan, dan pembagian trafik yang teramati. Dengan begitu, pembaca dapat membedakan <strong>target konfigurasi</strong> dari <strong>hasil pengujian</strong> pada cluster.</p><h3>Referensi</h3><ul><li><a href="https://github.com/mahendrarendi/knative-serving">Repository aplikasi dan manifest praktikum</a></li><li><a href="https://knative.dev/docs/serving/services/">Knative Serving dan konsep Service</a></li><li><a href="https://knative.dev/docs/serving/architecture/">Arsitektur Knative Serving</a></li><li><a href="https://knative.dev/docs/serving/request-flow/">Alur permintaan Knative</a></li><li><a href="https://knative.dev/docs/serving/autoscaling/">Autoscaling dan scale-to-zero</a></li><li><a href="https://knative.dev/docs/serving/autoscaling/autoscaling-metrics/">Metrik autoscaling</a></li><li><a href="https://knative.dev/docs/serving/traffic-management/">Traffic management</a></li><li><a href="https://knative.dev/docs/install/serving/install-serving-with-yaml/">Panduan instalasi Knative Serving</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/controllers/deployment/">Kubernetes Deployment</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale/">Kubernetes Horizontal Pod Autoscaling</a></li><li><a href="https://gateway-api.sigs.k8s.io/reference/api-types/httproute/">Gateway API HTTPRoute</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c5ec87d20d7a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitOps untuk Rilis Aplikasi ke Kubernetes dengan Helm dan Argo CD]]></title>
            <link>https://medium.com/@rendinicolasm/gitops-untuk-rilis-aplikasi-ke-kubernetes-dengan-helm-dan-argo-cd-47a2a1c689a8?source=rss-f5e3249994ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/47a2a1c689a8</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[helm]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[argo-cd]]></category>
            <category><![CDATA[gitops]]></category>
            <dc:creator><![CDATA[mahendrarendi]]></dc:creator>
            <pubDate>Sun, 08 Nov 2026 09:31:59 GMT</pubDate>
            <atom:updated>2026-11-08T10:22:06.404Z</atom:updated>
            <content:encoded><![CDATA[<p>Bagaimana kode aplikasi, Helm chart, dan Argo CD bekerja dalam satu alur rilis ke Kubernetes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8vnk-DDeEFbOchWh6L8rjw.png" /></figure><p>Bayangkan aplikasi di production bermasalah, lalu seseorang memperbaikinya langsung dengan kubectl edit di dalam kubernetes cluster. Masalahnya hilang. Dua minggu kemudian, versi baru dirilis, dan masalah yang sama muncul lagi, karena perbaikan tadi tidak pernah tercatat di Git.</p><p>Skenario seperti ini mudah terjadi ketika pengaturan bisa diubah langsung di cluster. Riwayat di Git memberi gambaran yang berbeda dari kondisi aplikasi yang sebenarnya, dan pada rilis berikutnya kita bisa tanpa sadar menimpa pengaturan yang masih dibutuhkan.</p><p>GitOps, Helm, dan Argo CD adalah cara saya mengatasinya. Masing-masing punya satu peran:</p><ul><li><strong>Git</strong> menyimpan kondisi aplikasi yang diinginkan.</li><li><strong>Helm</strong> membentuk manifest Kubernetes dari template dan values.</li><li><strong>Argo CD</strong> mencocokkan cluster dengan apa yang tercatat di Git.</li></ul><p>Saya jelaskan satu per satu, lalu menunjukkan satu rilis nyata di aplikasi LabK8stack, lab berbasis web yang saya buat untuk latihan troubleshooting Kubernetes.</p><h4>Apa itu GitOps dan apa peran Argo CD?</h4><p>GitOps menjadikan Git sebagai sumber kebenaran tunggal (<em>single source of truth</em>) untuk kondisi aplikasi yang diinginkan. Proyek OpenGitOps merumuskannya dalam empat prinsip: kondisi itu ditulis secara deklaratif, disimpan dengan riwayat versi, ditarik otomatis oleh agent, lalu terus dicocokkan dengan kondisi nyata (<a href="https://opengitops.dev/">OpenGitOps, <em>Principles</em></a>).</p><p>Di Kubernetes, Argo CD berperan sebagai agent itu. Ia membaca revisi Git yang ditunjuk, membandingkannya dengan resource di cluster, dan menerapkan perbedaannya saat sync (<a href="https://argo-cd.readthedocs.io/en/stable/user-guide/helm/">Argo CD, <em>Helm</em></a>).</p><p>Tiga alasan saya memakai GitOps dengan Argo CD:</p><ul><li><strong>Riwayat rilis bisa ditelusuri.</strong> Saya bisa membuka commit deployment untuk melihat konfigurasi apa yang berubah.</li><li><strong>Perubahan bisa ditinjau sebelum rilis.</strong> Pull request memberi tempat untuk membaca diff, misalnya saat referensi image berubah.</li><li><strong>Selisih di cluster terlihat.</strong> Kalau resource yang dikelola berubah di luar Git, Argo CD menunjukkan perbedaannya sebelum saya menentukan tindakan.</li></ul><h4>Bagaimana perubahan sampai ke cluster?</h4><p>Alur ini butuh dua hal yang sudah tersedia:</p><ul><li><strong>Cluster Kubernetes yang sudah memasang Argo CD.</strong> Argo CD berjalan sebagai komponen di dalam cluster, jadi cluster itu sendiri yang menarik konfigurasi dari Git, bukan alat dari luar yang mendorongnya (OpenGitOps, Principles).</li><li><strong>Repository Git berisi konfigurasi deployment</strong>, yaitu chart dan values. Repository ini bisa di GitHub, GitLab, atau layanan Git lain.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y3f0nVVPLQqg15cL-KjK-w.png" /><figcaption>Gambar 1. Alur GitOps</figcaption></figure><p>Dengan keduanya, perubahan berjalan dalam empat langkah:</p><ol><li>Perubahan konfigurasi di sebuah branch dan mengajukan pull request.</li><li>Perubahan ditinjau, lalu digabung (merge) ke branch utama.</li><li>Argo CD memeriksa repository secara berkala dan membaca revisi yang ditunjuk oleh resource Application, yang menentukan repo, revisi, lokasi konfigurasi, serta cluster dan namespace tujuan.</li><li>Kalau konfigurasi yang diinginkan berbeda dari kondisi cluster, aplikasi tampil sebagai OutOfSync.</li></ol><p>Setelah itu ada dua pilihan. Dengan <strong>manual sync</strong>, Argo CD hanya memberi tahu ada perbedaan, dan kita sendiri yang menerapkannya setelah memeriksa perubahannya. Dengan <strong>auto-sync</strong>, Argo CD langsung menerapkannya ke cluster (<a href="https://argo-cd.readthedocs.io/en/stable/user-guide/tracking_strategies/">Argo CD, Tracking and Deployment Strategies</a>).</p><h4>Dimana helm masuk?</h4><p>Manifest Kubernetes di Git bisa ditulis dalam beberapa bentuk. Argo CD bisa membaca YAML biasa, Kustomize, atau Helm chart (Argo CD, Application Sources). Dengan Helm, bentuk resource ditulis sekali sebagai <em>template</em>, sedangkan bagian yang berbeda antar-environment, seperti image dan jumlah replica, ditaruh di file <em>values</em> (<a href="https://helm.sh/docs/chart_template_guide/">Helm, Chart Template Guide</a>).</p><h4>Bagaimana Helm dan Argo CD diintegrasikan?</h4><p>Argo CD membaca chart dan values dari revisi Git yang ditunjuk. Lalu ia menjalankan helm template, yaitu perintah Helm yang mengubah chart dan values menjadi manifest Kubernetes biasa, dan membandingkan hasilnya dengan isi cluster (Argo CD, Helm). Jadi tugasnya terbagi. Helm menjawab “manifest apa yang harus dihasilkan?”, sedangkan Argo CD menjawab “apakah cluster sudah sesuai?”. Saat merilis versi baru, sering hanya referensi image di values yang diganti, dan templatenya tetap sama.</p><p>Referensi image itu berasal dari continuous integration (CI), yaitu proses yang menguji kode, membangun image, dan mengirimkannya ke registry, misalnya lewat GitHub Actions, GitLab CI/CD, atau Jenkins. Setelah image tersedia, referensinya dicatat di values dan diajukan lewat pull request, lalu alur GitOps tadi berjalan.</p><h4>Studi Kasus: Rilis Aplikasi LabK8stack dengan Helm dan Argo CD</h4><p>Sekarang kita lihat satu rilis nyata di <a href="https://lab.mahendrarendi.cloud/">LabK8stack</a>, aplikasi yang saya buat. Saya memisahkan kode aplikasi dan konfigurasi deployment ke dua repository:</p><ul><li><a href="https://github.com/mahendrarendi/labk8stack-app">labk8stack-app</a> menyimpan kode aplikasi yang dibangun menjadi container image.</li><li><a href="https://github.com/mahendrarendi/labk8stack-manifest">labk8stack-manifest</a> menyimpan konfigurasi deployment yang dibaca Argo CD.</li></ul><p>Satu rilis mengikuti alur ini:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w7h3mTOe03-JScWFfiVqsg.png" /><figcaption>Gambar 2. Flow Deployment.</figcaption></figure><p>Pertama, CI menerbitkan image ke GHCR, yaitu registry milik GitHub. Saya lalu mencatat <em>digest</em> image di Helm values. Digest adalah sidik jari unik sebuah image, jadi values selalu menunjuk ke image yang sama persis, walau nanti ada image lain dengan nama yang sama (<a href="https://kubernetes.io/docs/concepts/containers/images/">Kubernetes, Images</a>). Perubahan ini saya ajukan lewat pull request. Setelah digabung (merge), commit hasil merge menjadi versi konfigurasi yang siap dirilis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LQ1t958UE4GTnfcFn0j72g.png" /><figcaption>Gambar 3. Dashboard ArgoCD</figcaption></figure><p>Di tampilan <strong>Applications</strong> Argo CD, kartu labk8stack menunjukkan bahwa production mengarah ke namespace labk8stack dan <strong>Target Revision</strong> dipatok ke commit ab79938 (<a href="https://argo-cd.readthedocs.io/en/stable/user-guide/tracking_strategies/">Argo CD, <em>Tracking and Deployment Strategies</em></a>). Untuk rilis berikutnya, saya perlu mengubah targetRevision ke commit hasil merge dan menerapkan ulang manifest Application yang saya kelola terpisah (<a href="https://argo-cd.readthedocs.io/en/stable/user-guide/tracking_strategies/">Argo CD, <em>Tracking and Deployment Strategies</em></a>). Setelah Argo CD membaca revisi baru, saya bisa meninjau diff dan menjalankan sync manual.</p><h4>Kapan rilis bisa dibilang berhasil?</h4><p>Di halaman detail LabK8stack, <strong>Sync OK</strong> menunjukkan bahwa operasi sync terakhir untuk commit ab79938 berhasil. <strong>Synced</strong> menunjukkan resource di cluster sudah sesuai dengan konfigurasi dari revisi itu, sementara <strong>Healthy</strong> menunjukkan resource lolos pemeriksaan kesehatan Argo CD.</p><p>Di tampilan yang sama, kita bisa melihat jalur yang dikonfigurasi untuk aplikasi. HTTPRoute mengarah ke Service LabK8stack, yang terhubung ke dua Pod aplikasi. Keduanya terlihat Running dengan status 1/1 siap.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Me5_OhuUM7UbTVkp8sfUhA.png" /><figcaption>Gambar 4. <em>Hasil sync dan jalur dari HTTPRoute ke dua Pod LabK8stack.</em></figcaption></figure><p>Untuk melihat hasilnya dari sisi user, buka <a href="https://lab.mahendrarendi.cloud/">LabK8stack</a> dan coba salah satu skenario troubleshooting Kubernetes langsung dari browser.</p><h4>Rangkuman</h4><p>GitOps menjadikan Git sebagai rujukan, Helm membentuk manifest dari chart dan values, dan Argo CD mencocokkan cluster dengan hasilnya. Di LabK8stack, satu rilis berarti image dengan digest, commit di repo manifest, targetRevision yang dipatok, lalu sync manual. Dari situ saya bisa menjawab apa yang berubah dan apakah cluster sudah sesuai, tanpa menebak. Helm dan Argo CD bukan dua cara berbeda untuk men-deploy aplikasi, melainkan dua bagian dari alur yang sama.</p><h4>Referensi</h4><ul><li>OpenGitOps, <em>Principles</em> — <a href="https://opengitops.dev/">https://opengitops.dev/</a></li><li>Argo CD, <em>Helm</em> — <a href="https://argo-cd.readthedocs.io/en/stable/user-guide/helm/">https://argo-cd.readthedocs.io/en/stable/user-guide/helm/</a></li><li>Argo CD, <em>Tracking and Deployment Strategies</em> — <a href="https://argo-cd.readthedocs.io/en/stable/user-guide/tracking_strategies/">https://argo-cd.readthedocs.io/en/stable/user-guide/tracking_strategies/</a></li><li>Helm, <em>Chart Template Guide</em> — <a href="https://helm.sh/docs/chart_template_guide/">https://helm.sh/docs/chart_template_guide/</a></li><li>Kubernetes, <em>Images</em> — <a href="https://kubernetes.io/docs/concepts/containers/images/">https://kubernetes.io/docs/concepts/containers/images/</a></li><li>LabK8stack, <em>Repository aplikasi</em> — <a href="https://github.com/mahendrarendi/labk8stack-app">https://github.com/mahendrarendi/labk8stack-app</a></li><li>LabK8stack, <em>Repository manifest deployment</em> — <a href="https://github.com/mahendrarendi/labk8stack-manifest">https://github.com/mahendrarendi/labk8stack-manifest</a></li><li>LabK8stack deployment, <em>README · Release Workflow</em> — <a href="https://github.com/mahendrarendi/labk8stack-manifest#release-workflow">https://github.com/mahendrarendi/labk8stack-manifest#release-workflow</a></li><li>LabK8stack, <em>Akses lab troubleshooting Kubernetes</em> — <a href="https://lab.mahendrarendi.cloud/">https://lab.mahendrarendi.cloud/</a></li><li>Prasta Maha, Manage Argocd Gitops Easier with Helm — <a href="https://medium.com/prastamaha/manage-argocd-gitops-easier-with-helm-30133331e75a">https://medium.com/prastamaha/manage-argocd-gitops-easier-with-helm-30133331e75a</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=47a2a1c689a8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes Object (2): Cara Kubernetes Mengelola Akses, Konfigurasi, dan Penyimpanan Aplikasi]]></title>
            <link>https://medium.com/@rendinicolasm/kubernetes-object-2-cara-kubernetes-mengelola-akses-konfigurasi-dan-penyimpanan-aplikasi-02854dfabc9a?source=rss-f5e3249994ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/02854dfabc9a</guid>
            <category><![CDATA[kubernetes-storage]]></category>
            <category><![CDATA[kubernetes-networking]]></category>
            <category><![CDATA[kubernetes-ingress]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[mahendrarendi]]></dc:creator>
            <pubDate>Sun, 01 Nov 2026 04:56:36 GMT</pubDate>
            <atom:updated>2026-11-01T04:56:36.872Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X33CxfThhdqyrH2BZnEfZw.png" /><figcaption>Gambar 1. Overview</figcaption></figure><p>Di artikel sebelumnya, <a href="https://medium.com/@rendinicolasm/kubernetes-object-1-cara-kubernetes-mengelola-lifecycle-aplikasi-dan-workload-706736d9abaf">Kubernetes Object (1): Cara Kubernetes Mengelola Lifecycle Aplikasi dan Workload</a>, kita menjalankan Nginx lewat Deployment dan melihat Kubernetes menjaga jumlah Pod, melakukan scaling, rolling update, dan rollback. Tapi masih ada tiga pertanyaan yang belum terjawab.</p><ul><li>Pertama, Pod sudah berjalan, lalu bagaimana cara kita mengaksesnya?</li><li>Kedua, bagaimana memisahkan konfigurasi aplikasi, seperti pengaturan dan password, dari image dan dari YAML?</li><li>Ketiga, ketika sebuah Pod dihapus, datanya ikut hilang, seperti tabel PostgreSQL di db-0 pada artikel sebelumnya. Jadi bagaimana aplikasi seperti database menyimpan datanya?</li></ul><p>Tiga pertanyaan itulah inti artikel ini: <strong>networking</strong> lewat Service dan Ingress, <strong>konfigurasi</strong> lewat ConfigMap dan Secret, dan <strong>storage</strong> lewat PersistentVolume, PersistentVolumeClaim, dan StorageClass.</p><h4>1. Service: Satu Alamat Tetap untuk Pod yang Terus Berganti</h4><p>Coba lihat IP Pod dari Deployment kita:</p><pre>root@cntrl1ab01:~# kubectl get pods -n lab -l app=web -o wide<br>NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE          NOMINATED NODE   READINESS GATES<br>web-57794f8f99-b4n8c   1/1     Running   0          26m   10.244.1.14   srvwrk1ab01   &lt;none&gt;           &lt;none&gt;<br>web-57794f8f99-hn4kc   1/1     Running   0          26m   10.244.2.11   srvwrk1ab02   &lt;none&gt;           &lt;none&gt;<br>web-57794f8f99-xwhbt   1/1     Running   0          26m   10.244.1.15   srvwrk1ab01   &lt;none&gt;           &lt;none&gt;</pre><p>Setiap Pod punya IP sendiri, tetapi IP itu tidak bisa diandalkan. Ketika sebuah Pod diganti, IP-nya ikut berganti. Kalau aplikasi lain menyimpan IP Pod secara langsung, koneksinya akan putus setiap kali ada perubahan.</p><p><strong>Service</strong> menyelesaikan masalah ini. Service adalah object yang memberi alamat tetap (IP virtual dan nama DNS) untuk sekumpulan Pod, lalu membagi trafik ke Pod-Pod yang sehat (<a href="https://kubernetes.io/docs/concepts/services-networking/service/">Kubernetes Documentation — Service</a>).</p><p>Service tahu Pod mana yang harus dituju lewat <em>label</em>. Pod dari Deployment kita sudah diberi label app: web. Di Service, kita cukup menulis “pilih semua Pod berlabel app: web”, dan Kubernetes yang mencarikannya. Aturan pemilihan ini disebut <em>selector</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*In64E0QjyijUDLANVlsvOg.png" /><figcaption>Gambar 2. Service sebagai alamat tetap untuk sekumpulan Pod</figcaption></figure><p>Ada tiga tipe Service yang paling sering dipakai (<a href="https://kubernetes.io/docs/concepts/services-networking/service/">Kubernetes Documentation — Service</a>):</p><ul><li><strong>ClusterIP</strong> (default): hanya bisa diakses dari dalam cluster.</li><li><strong>NodePort</strong>: membuka sebuah port (rentang 30000–32767) di setiap node, sehingga bisa diakses dari luar cluster.</li><li><strong>LoadBalancer</strong>: meminta load balancer eksternal. Di cloud, ini disediakan oleh provider. Di cluster on-premise atau bare metal, kita butuh komponen tambahan seperti <strong>MetalLB</strong>.</li></ul><p>File service-web.yaml</p><pre>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: web<br>  namespace: lab<br>spec:<br>  selector:<br>    app: web<br>  ports:<br>    - port: 80<br>      targetPort: 80</pre><p>Bagian selector memilih Pod berlabel app: web. port adalah port Service, sedangkan targetPort adalah port container di dalam Pod. Terapkan manifest-nya:</p><pre>root@cntrl1ab01:~# kubectl apply -f service-web.yaml<br>service/web created</pre><p>Periksa Service-nya:</p><pre>root@cntrl1ab01:~# kubectl get service -n lab<br>NAME   TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE<br>web    ClusterIP   10.96.142.35   &lt;none&gt;        80/TCP    8s</pre><p>Lalu lihat alamat Pod yang saat ini menjadi tujuan Service:</p><pre>root@cntrl1ab01:~# kubectl get endpointslices -n lab -l kubernetes.io/service-name=web<br>NAME        ADDRESSTYPE   PORTS   ENDPOINTS                             AGE<br>web-7hq2d   IPv4          80      10.244.1.14,10.244.2.11,10.244.1.15   15s</pre><p>Bandingkan kolom ENDPOINTS dengan kolom IP pada kubectl get pods -o wide tadi: seharusnya sama.</p><p>Sekarang kita uji dari dalam cluster dengan Pod sementara. Di dalam namespace yang sama, Service bisa dipanggil langsung dengan namanya:</p><pre>root@cntrl1ab01:~/# kubectl run curl-test -n lab --rm -it --restart=Never --image=curlimages/curl -- curl -s http://web<br>&lt;!DOCTYPE html&gt;<br>&lt;html&gt;<br>&lt;head&gt;<br>&lt;title&gt;Welcome to nginx!&lt;/title&gt;<br>...<br>&lt;/html&gt;<br>pod &quot;curl-test&quot; deleted</pre><p>Kalau berhasil, halaman default Nginx akan tampil. Nama lengkap Service ini sebenarnya web.lab.svc.cluster.local, dan itulah nama yang dipakai aplikasi lain dari namespace berbeda (<a href="https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/">Kubernetes Documentation - DNS for Services and Pods</a>).</p><p>Untuk membuktikan alamatnya tetap, hapus salah satu Pod:</p><pre>root@cntrl1ab01:~# kubectl delete pod web-57794f8f99-b4n8c -n lab<br>pod &quot;web-57794f8f99-b4n8c&quot; deleted</pre><p>Lalu ulangi perintah curl tadi:</p><pre>root@cntrl1ab01:~# kubectl run curl-test -n lab --rm -it --restart=Never --image=curlimages/curl -- curl -s http://web<br>&lt;!DOCTYPE html&gt;<br>&lt;html&gt;<br>&lt;head&gt;<br>&lt;title&gt;Welcome to nginx!&lt;/title&gt;<br>...<br>&lt;/html&gt;<br>pod &quot;curl-test&quot; deleted</pre><p>Pod baru dengan IP baru dibuat oleh ReplicaSet, tetapi http://web tetap bisa diakses tanpa perubahan apa pun.</p><p><strong>Mengakses dari luar cluster dengan NodePort</strong></p><p>Untuk percobaan cepat dari luar cluster, ubah tipe Service menjadi NodePort:</p><pre>root@cntrl1ab01:~# kubectl patch service web -n lab -p &#39;{&quot;spec&quot;:{&quot;type&quot;:&quot;NodePort&quot;}}&#39;<br>service/web patched</pre><p>Lihat port yang dipilih Kubernetes:</p><pre>root@cntrl1ab01:~# kubectl get service web -n lab<br>NAME   TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE<br>web    NodePort   10.96.142.35   &lt;none&gt;        80:31245/TCP   4m</pre><p>Lalu lihat IP node:</p><pre>root@cntrl1ab01:~# kubectl get nodes -o wide<br>NAME          STATUS   ROLES           AGE   VERSION   INTERNAL-IP    EXTERNAL-IP   OS-IMAGE          KERNEL-VERSION          CONTAINER-RUNTIME<br>srvcp1ab01    Ready    control-plane   22d   v1.36.0   10.87.44.20    &lt;none&gt;        Talos (v1.14.1)   6.18.51-talos (amd64)   containerd://2.3.5<br>srvcp1ab02    Ready    control-plane   22d   v1.36.0   10.87.44.221   &lt;none&gt;        Talos (v1.14.1)   6.18.51-talos (amd64)   containerd://2.3.5<br>srvcp1ab03    Ready    control-plane   22d   v1.36.0   10.87.44.34    &lt;none&gt;        Talos (v1.14.1)   6.18.51-talos (amd64)   containerd://2.3.5<br>srvwrk1ab01   Ready    &lt;none&gt;          22d   v1.36.0   10.87.44.248   &lt;none&gt;        Talos (v1.14.1)   6.18.51-talos (amd64)   containerd://2.3.5<br>srvwrk1ab02   Ready    &lt;none&gt;          22d   v1.36.0   10.87.44.60    &lt;none&gt;        Talos (v1.14.1)   6.18.51-talos (amd64)   containerd://2.3.5<br>root@cntrl1ab01:~#</pre><p>Kolom PORT(S) menampilkan 80:31245/TCP, dengan angka belakang adalah NodePort yang dipilih Kubernetes. Dari mesin yang bisa menjangkau node, akses http://&lt;IP-node&gt;:&lt;NodePort&gt;, misalnya <a href="http://10.10.10.21:31245.">http://10.87.44.60:31245.</a></p><blockquote>NodePort cocok untuk percobaan, tetapi kurang ideal untuk dipakai terus: kita harus mengingat port acak, dan setiap aplikasi memakai port berbeda. Untuk aplikasi web, ada cara yang lebih rapi.</blockquote><h4>Ingress: Satu Pintu Masuk untuk Banyak Aplikasi</h4><p>Bayangkan kita punya sepuluh aplikasi web. Membuat satu LoadBalancer untuk masing-masing akan boros dan sulit diatur. <strong>Ingress</strong> menyelesaikannya dengan satu pintu masuk HTTP/HTTPS yang mengarahkan trafik ke Service yang berbeda berdasarkan nama host atau path (<a href="https://kubernetes.io/docs/concepts/services-networking/ingress/">Kubernetes Documentation — Ingress</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Pf_KHA_BPXkAH97G9OGYOA.png" /><figcaption>Gambar 3. Alur trafik dari client melalui Ingress ke Pod</figcaption></figure><p>Ada satu hal penting yang sering terlewat: object Ingress saja tidak melakukan apa-apa. Ia hanya berisi aturan. Yang menjalankan aturan itu adalah <strong>Ingress controller</strong>, yang harus dipasang terpisah di cluster (<a href="https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/">Kubernetes Documentation — Ingress Controllers</a>).</p><blockquote>NGINX Ingress Controller yang dikelola komunitas Kubernetes (ingress-nginx) sudah dipensiunkan sejak Maret 2026 dan tidak lagi menerima pembaruan keamanan, jadi tidak disarankan untuk instalasi baru (<a href="https://www.kubernetes.io/blog/2025/11/11/ingress-nginx-retirement/">Kubernetes Blog - Ingress NGINX Retirement: What You Need to Know</a>). Ada controller lain dengan nama mirip yang dikelola F5, tetapi itu proyek yang berbeda.</blockquote><p>Berikut contoh aturan Ingress untuk Service web kita:</p><pre>apiVersion: networking.k8s.io/v1<br>kind: Ingress<br>metadata:<br>  name: web<br>  namespace: lab<br>spec:<br>  ingressClassName: nginx<br>  rules:<br>    - host: web.lab.local<br>      http:<br>        paths:<br>          - path: /<br>            pathType: Prefix<br>            backend:<br>              service:<br>                name: web<br>                port:<br>                  number: 80</pre><p>Aturannya terbaca seperti kalimat: permintaan ke host web.lab.local dengan path berawalan / diteruskan ke Service web di port 80. Nilai ingressClassName mengikuti controller yang terpasang di cluster.</p><blockquote><strong>U</strong>ntuk kebutuhan routing yang lebih kaya, dokumentasi Kubernetes juga memperkenalkan <strong>Gateway API</strong> sebagai penerus Ingress. Konsepnya mirip, jadi memahami Ingress tetap menjadi fondasi yang baik (<a href="https://kubernetes.io/docs/concepts/services-networking/gateway/">Kubernetes Documentation — Gateway API</a>).</blockquote><h4>2. ConfigMap dan Secret: Ubah Konfigurasi Tanpa Membangun Ulang Image</h4><p>Konfigurasi aplikasi seperti mode environment, alamat database, atau password sebaiknya tidak ditulis di dalam image. Kalau ditulis di sana, mengubah satu nilai berarti membangun ulang image, dan image yang sama tidak bisa dipakai di lingkungan yang berbeda.</p><p>Kubernetes menyediakan dua object untuk itu:</p><ul><li><strong>ConfigMap</strong> untuk konfigurasi yang tidak sensitif (<a href="https://kubernetes.io/docs/concepts/configuration/configmap/">Kubernetes Documentation — ConfigMaps</a>).</li><li><strong>Secret</strong> untuk data sensitif seperti password, token, atau sertifikat (<a href="https://kubernetes.io/docs/concepts/configuration/secret/">Kubernetes Documentation — Secrets</a>).</li></ul><p>Keduanya bisa dipakai oleh Pod sebagai environment variable atau sebagai file yang di-mount ke dalam container.</p><p><strong>Membuat ConfigMap dan Secret</strong></p><p>Buat satu ConfigMap dan satu Secret langsung dari terminal. Pertama, ConfigMap:</p><pre>root@cntrl1ab01:~# kubectl create configmap app-config -n lab \<br>  --from-literal=APP_ENV=learning \<br>  --from-literal=APP_MESSAGE=&quot;Halo dari ConfigMap&quot;<br>configmap/app-config created</pre><p>Lalu untuk secret:</p><pre>root@cntrl1ab01:~# kubectl create secret generic app-secret -n lab \<br>  --from-literal=DB_PASSWORD=8erc4nday4!<br>secret/app-secret created</pre><p>Lihat isi ConfigMap dalam bentuk YAML:</p><pre>root@cntrl1ab01:~# kubectl get configmap app-config -n lab -o yaml<br>apiVersion: v1<br>data:<br>  APP_ENV: learning<br>  APP_MESSAGE: Halo dari ConfigMap<br>kind: ConfigMap<br>metadata:<br>  creationTimestamp: &quot;2026-11-01T07:41:12Z&quot;<br>  name: app-config<br>  namespace: lab<br>  resourceVersion: &quot;184213&quot;<br>  uid: 5b1c0e6a-2f7d-4a3b-9c58-0d7f3e91a2b4</pre><p>Lalu secret:</p><pre>root@cntrl1ab01:~# kubectl get secret app-secret -n lab -o yaml<br>apiVersion: v1<br>data:<br>  DB_PASSWORD: OGVyYzRuZGF5NCE=<br>kind: Secret<br>metadata:<br>  creationTimestamp: &quot;2026-11-01T07:41:30Z&quot;<br>  name: app-secret<br>  namespace: lab<br>  resourceVersion: &quot;184230&quot;<br>  uid: 9e4a7d12-83c6-4f0b-a1d5-6c2b8f3e7a09<br>type: Opaque</pre><p>Perhatikan perbedaannya: nilai ConfigMap terbaca jelas, sedangkan nilai Secret tampil sebagai deretan karakter acak.</p><p><strong>Base64 Bukan Enkripsi</strong></p><p>Deretan karakter acak tadi adalah base64. Coba decode:</p><pre>root@cntrl1ab01:~# kubectl get secret app-secret -n lab -o jsonpath=&#39;{.data.DB_PASSWORD}&#39; | base64 -d<br>8erc4nday4!</pre><p>Passwordnya langsung terbaca. Inilah poin yang sering disalahpahami.</p><blockquote>base64 hanyalah encoding, bukan enkripsi. Secret tersimpan di etcd, dan siapa pun yang punya akses API untuk membacanya bisa mendecode isinya (Kubernetes Documentation — Secrets). Karena itu, pembatasan akses lewat RBAC, enkripsi etcd <em>at rest</em>, atau secret manager eksternal tetap diperlukan untuk lingkungan produksi (<a href="https://kubernetes.io/docs/concepts/security/secrets-good-practices/">Kubernetes Documentation — Good practices for Kubernetes Secrets</a>).</blockquote><p><strong>Memakai ConfigMap dan Secret di Pod</strong></p><p>Sekarang kita pakai keduanya di dalam sebuah Pod. Buat file config-pod.yaml:</p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: config-demo<br>  namespace: lab<br>spec:<br>  restartPolicy: Never<br>  containers:<br>    - name: demo<br>      image: busybox:1.36<br>      command:<br>        - sh<br>        - -c<br>        - echo &quot;$APP_MESSAGE ($APP_ENV)&quot;; sleep 3600<br>      envFrom:<br>        - configMapRef:<br>            name: app-config<br>      env:<br>        - name: DB_PASSWORD<br>          valueFrom:<br>            secretKeyRef:<br>              name: app-secret<br>              key: R4h4s!ah4h4h4h4</pre><p>Bagian envFrom memasukkan semua isi ConfigMap sebagai environment variable, sedangkan secretKeyRef mengambil satu key dari Secret. Terapkan manifest-nya:</p><pre>root@cntrl1ab01:~# kubectl apply -f config-pod.yaml<br>pod/config-demo created</pre><p>Pastikan pod nya berjalan:</p><pre>root@cntrl1ab01:~# kubectl get pod config-demo -n lab<br>NAME          READY   STATUS    RESTARTS   AGE<br>config-demo   1/1     Running   0          7s</pre><p>Lihat log nya:</p><pre>root@cntrl1ab01:~# kubectl logs config-demo -n lab<br>Halo dari ConfigMap (learning)</pre><p>Periksa password dari Secret di dalam container:</p><pre>root@cntrl1ab01:~# kubectl exec config-demo -n lab -- sh -c &#39;echo $DB_PASSWORD&#39;<br>R4h4s!ah4h4h4h4</pre><p>Log menampilkan pesan dari ConfigMap, dan perintah exec menampilkan password dari Secret. Artinya, aplikasi di dalam container menerima nilai-nilai itu tanpa ada satu pun yang tertulis di image. Mengubah konfigurasi cukup dengan mengubah ConfigMap atau Secret, tanpa membangun ulang image. Perlu diingat, nilai environment variable dibaca saat container dimulai, jadi Pod perlu dibuat ulang supaya membaca nilai yang baru.</p><h4>3. Storage: PersistentVolume, PersistentVolumeClaim, dan StorageClass</h4><p>Coba bayangkan sebuah database yang berjalan di dalam Pod. Ketika Pod itu dihapus atau dipindah ke node lain, apa yang terjadi pada datanya? Secara default, filesystem container bersifat sementara. Pod hilang, data ikut hilang (<a href="https://kubernetes.io/docs/concepts/storage/volumes/">Kubernetes Documentation — Volumes</a>). Itulah yang kita lihat pada db-0 di artikel sebelumnya.</p><p>Untuk data yang harus bertahan, Kubernetes memisahkan urusan storage menjadi tiga object (<a href="https://kubernetes.io/docs/concepts/storage/persistent-volumes/">Kubernetes Documentation — Persistent Volumes</a>):</p><ul><li><strong>PersistentVolume (PV)</strong> adalah storage sebenarnya yang tersedia di cluster. Sumbernya bisa bermacam-macam, misalnya disk lokal di node, share NFS, SAN lewat iSCSI atau Ceph, storage array enterprise seperti NetApp ONTAP (<a href="https://kubernetes.io/docs/concepts/storage/persistent-volumes/">Kubernetes Documentation — Persistent Volumes</a>).</li><li><strong>PersistentVolumeClaim (PVC)</strong> adalah permintaan storage dari sisi aplikasi: “saya butuh 1 GiB dengan akses tertentu”.</li><li><strong>StorageClass</strong> menjelaskan jenis storage dan cara membuatnya secara otomatis. Dengan StorageClass, PV dibuat sendiri begitu ada PVC yang memintanya (<em>dynamic provisioning</em>) (<a href="https://kubernetes.io/docs/concepts/storage/storage-classes/">Kubernetes Documentation — Storage Classes</a>).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VxARGPDWc9DKXJzfnNNKzA.png" /><figcaption>Gambar 4. Hubungan Pod, PVC, PV, dan StorageClass</figcaption></figure><p>Pemisahan ini membuat tim aplikasi cukup meminta storage lewat PVC tanpa perlu tahu storage-nya diambil dari mana. Itu urusan StorageClass dan admin cluster.</p><p><strong>Persistent Volume: Data yang Bertahan setelah Pod Dihapus</strong></p><p>Pertama, cek apakah cluster kita sudah punya StorageClass:</p><pre>root@cntrl1ab01:~# kubectl get storageclass<br>NAME                   PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE<br>local-path (default)   rancher.io/local-path   Delete          WaitForFirstConsumer   false                  15d</pre><blockquote><strong>C</strong>luster Kubernetes yang baru dibangun, termasuk cluster Talos, tidak selalu punya StorageClass bawaan. Kalau daftar di atas kosong, PVC pada praktikum ini akan tertahan di status Pending karena belum ada yang menyediakan volume. Kita perlu memasang provisioner storage (CSI driver) lebih dulu.</blockquote><p>Langkah pemasangannya tidak kita bahas di sini, karena bergantung pada storage yang tersedia. Pilihan driver dan konfigurasinya harus disesuaikan dengan kebutuhan, misalnya :</p><ul><li><strong>NFS:</strong> StorageClass untuk driver NFS memakai parameter server dan share, yang diisi dengan alamat server NFS dan nama share (<a href="https://github.com/kubernetes-csi/csi-driver-nfs/blob/8276121306f2/deploy/example/README.md">NFS CSI Driver for Kubernetes</a>).</li><li><strong>ONTAP:</strong> Konfigurasi backend Trident memakai TridentBackendConfig yang merujuk ke SVM dan management LIF ONTAP, dengan kredensial disimpan di Secret Kubernetes (<a href="https://docs.netapp.com/us-en/netapp-solutions-containers/vsphere-kubernetes-service/install-trident.html">NetApp Documentation - Install Trident</a>).</li></ul><p>Jika StorageClass sudah tersedia di cluster kamu, buat file pvc.yaml:</p><pre>apiVersion: v1<br>kind: PersistentVolumeClaim<br>metadata:<br>  name: data-pvc<br>  namespace: lab<br>spec:<br>  accessModes:<br>    - ReadWriteOnce<br>  resources:<br>    requests:<br>      storage: 1Gi</pre><p>ReadWriteOnce berarti volume bisa di-mount dengan akses baca-tulis oleh satu node pada satu waktu (<a href="https://kubernetes.io/docs/concepts/storage/persistent-volumes/">Kubernetes Documentation - Persistent Volumes</a>). Lalu buat file storage-pod.yaml yang memakai PVC itu:</p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: storage-demo<br>  namespace: lab<br>spec:<br>  containers:<br>    - name: demo<br>      image: busybox:1.36<br>      command: [&quot;sh&quot;, &quot;-c&quot;, &quot;date &gt;&gt; /data/log.txt; sleep 3600&quot;]<br>      volumeMounts:<br>        - name: data<br>          mountPath: /data<br>  volumes:<br>    - name: data<br>      persistentVolumeClaim:<br>        claimName: data-pvc</pre><p>Terapkan PVC-nya lebih dulu:</p><pre>root@cntrl1ab01:~# kubectl apply -f pvc.yaml<br>persistentvolumeclaim/data-pvc created</pre><p>Lalu pod nya:</p><pre>root@cntrl1ab01:~# kubectl apply -f storage-pod.yaml<br>pod/storage-demo created</pre><p>Lihat stutus PVC nya:</p><pre>root@cntrl1ab01:~# kubectl get pvc -n lab<br>NAME       STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   VOLUMEATTRIBUTESCLASS   AGE<br>data-pvc   Bound    pvc-3f6a8e21-5c1d-4b7a-9e02-8d4c1f7b6a35   1Gi        RWO            local-path     &lt;unset&gt;                 14s</pre><p>Lalu lihat PV yang dibuat otomatis oleh StorageClass:</p><pre>root@cntrl1ab01:~# kubectl get pv<br>NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM          STORAGECLASS   VOLUMEATTRIBUTESCLASS   REASON   AGE<br>pvc-3f6a8e21-5c1d-4b7a-9e02-8d4c1f7b6a35   1Gi        RWO            Delete           Bound    lab/data-pvc   local-path     &lt;unset&gt;                          9s</pre><p>Perhatikan status Bound: PVC sudah terikat ke sebuah PV yang tidak kita buat sendiri. Kalau StorageClass memakai mode WaitForFirstConsumer seperti contoh di atas, PVC baru terikat setelah ada Pod yang memakainya, jadi statusnya bisa Pending sebentar sebelum Pod dibuat.</p><p>Pod ini menulis tanggal saat ini ke file /data/log.txt di volume. Sekarang hapus Pod-nya:</p><pre>root@cntrl1ab01:~# kubectl delete pod storage-demo -n lab<br>pod &quot;storage-demo&quot; deleted</pre><p>Buat lagi dari manifest yang sama:</p><pre>root@cntrl1ab01:~# kubectl apply -f storage-pod.yaml<br>pod/storage-demo created</pre><p>Tunggu sampai Pod siap:</p><pre>root@cntrl1ab01:~# kubectl wait --for=condition=Ready pod/storage-demo -n lab<br>pod/storage-demo condition met</pre><p>Lalu baca file di volume:</p><pre>root@cntrl1ab01:~# kubectl exec storage-demo -n lab -- cat /data/log.txt<br>Sun Nov  1 15:02:41 UTC 2026<br>Sun Nov  1 15:04:09 UTC 2026</pre><p>File berisi dua baris tanggal: satu dari Pod pertama dan satu dari Pod kedua. Pod sudah diganti, tetapi datanya tetap ada karena tersimpan di volume, bukan di dalam container.</p><p>Inilah yang dipakai StatefulSet lewat <em>volume claim template</em> untuk memberi storage tersendiri pada setiap Pod-nya. Dengan cara yang sama, StatefulSet db dari artikel sebelumnya bisa diberi storage, sehingga tabel catatan di db-0 tidak hilang saat Pod-nya dihapus (Kubernetes Documentation - StatefulSet).</p><h4>4. Rangkuman: Object Mana untuk Kebutuhan Apa?</h4><p>Pemilihan object sebaiknya mengikuti kebutuhan aplikasi:</p><ul><li><strong>Akses (Networking):</strong> Pod punya IP yang berubah setiap kali diganti, jadi <strong>Service</strong> dipakai sebagai alamat tetap di depan sekumpulan Pod. Untuk aplikasi web, <strong>Ingress</strong> menjadi satu pintu masuk HTTP/HTTPS yang mengarahkan trafik berdasarkan host dan path.</li><li><strong>Konfigurasi:</strong> pengaturan yang tidak sensitif disimpan di <strong>ConfigMap</strong>, sedangkan data sensitif seperti password disimpan di <strong>Secret</strong>. Isi Secret hanya di-encode dengan base64, bukan dienkripsi, jadi akses ke Secret tetap harus dibatasi.</li><li>Data (Storage): aplikasi meminta storage lewat PersistentVolumeClaim, lalu StorageClass membuat PersistentVolume secara otomatis. Mekanisme ini disebut <em>dynamic provisioning</em>, jadi kita tidak perlu membuat PV dan mencocokkannya dengan PVC secara manual. Karena data tersimpan di volume dan bukan di dalam container, Pod boleh hilang tanpa membawa datanya.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UbfBYvwN8uU1S6kap14BZQ.png" /><figcaption>Tabel 1. Ringkasan Object Networking, Konfigurasi, dan Storage</figcaption></figure><h4>Referensi</h4><ul><li><a href="https://kubernetes.io/docs/concepts/services-networking/service/">Kubernetes Documentation — Service</a></li><li><a href="https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/">Kubernetes Documentation — DNS for Services and Pods</a></li><li><a href="https://kubernetes.io/docs/concepts/services-networking/ingress/">Kubernetes Documentation — Ingress</a></li><li><a href="https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/">Kubernetes Documentation — Ingress Controllers</a></li><li><a href="https://www.kubernetes.io/blog/2025/11/11/ingress-nginx-retirement/">Kubernetes Blog — Ingress NGINX Retirement: What You Need to Know</a></li><li><a href="https://kubernetes.io/docs/concepts/services-networking/gateway/">Kubernetes Documentation — Gateway API</a></li><li><a href="https://kubernetes.io/docs/concepts/configuration/configmap/">Kubernetes Documentation — ConfigMaps</a></li><li><a href="https://kubernetes.io/docs/concepts/configuration/secret/">Kubernetes Documentation — Secrets</a></li><li><a href="https://kubernetes.io/docs/concepts/security/secrets-good-practices/">Kubernetes Documentation — Good practices for Kubernetes Secrets</a></li><li><a href="https://kubernetes.io/docs/concepts/storage/volumes/">Kubernetes Documentation — Volumes</a></li><li><a href="https://kubernetes.io/docs/concepts/storage/persistent-volumes/">Kubernetes Documentation — Persistent Volumes</a></li><li><a href="https://kubernetes.io/docs/concepts/storage/storage-classes/">Kubernetes Documentation — Storage Classes</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/">Kubernetes Documentation — StatefulSet</a></li><li><a href="https://github.com/kubernetes-csi/csi-driver-nfs/blob/8276121306f2/deploy/example/README.md">NFS CSI Driver for Kubernetes</a></li><li><a href="https://docs.netapp.com/us-en/netapp-solutions-containers/vsphere-kubernetes-service/install-trident.html">NetApp Documentation — Install Trident</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=02854dfabc9a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes Object (1): Cara Kubernetes Mengelola Lifecycle Aplikasi dan Workload]]></title>
            <link>https://medium.com/@rendinicolasm/kubernetes-object-1-cara-kubernetes-mengelola-lifecycle-aplikasi-dan-workload-706736d9abaf?source=rss-f5e3249994ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/706736d9abaf</guid>
            <category><![CDATA[kubernetes-object]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-native]]></category>
            <dc:creator><![CDATA[mahendrarendi]]></dc:creator>
            <pubDate>Sun, 25 Oct 2026 03:34:45 GMT</pubDate>
            <atom:updated>2026-10-25T03:34:45.170Z</atom:updated>
            <content:encoded><![CDATA[<p>Pada artikel sebelumnya, <a href="https://medium.com/@rendinicolasm/membangun-kubernetes-cluster-dengan-talos-linux-memahami-etcd-scaling-dan-high-availability-ff8d5f7a6814">Membangun Kubernetes Cluster dengan Talos Linux: Memahami ETCD, Scaling, dan High Availability</a>, saya membangun cluster dari satu control plane hingga tiga control plane dan dua worker. Cluster itu sudah berdiri, tetapi masih kosong: belum ada satu pun aplikasi yang berjalan di dalamnya.</p><p>Di server Linux konvensional, kita menjalankan aplikasi lewat Docker atau systemd dan menentukan sendiri di mana ia berjalan. Kubernetes bekerja sebaliknya: kita hanya mendeskripsikan kondisi yang diinginkan, lalu Kubernetes yang mewujudkan dan menjaganya. Pendekatan <em>declarative</em> inilah dasar dari Kubernetes Objects, dan di artikel ini kita mulai dari Namespace, Pod, ReplicaSet, hingga Deployment, sambil mengamati apa yang terjadi saat aplikasi dihapus, jumlah replikanya berubah, atau versinya diperbarui (<a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/">Kubernetes Documentation — Objects in Kubernetes</a>). Setelah itu, saya juga mengenalkan StatefulSet, DaemonSet, dan Job untuk kebutuhan workload yang berbeda.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JHvBLZS96v4wim_xRZhfMQ.png" /><figcaption>Gambar 1. Kubernetes Cluster</figcaption></figure><h4><strong>1. Cara berpikir Kubernetes: desired state</strong></h4><p>Sebelum menjalankan aplikasi pertama di kubernetes, ada satu prinsip yang perlu dipahami: Kubernetes bekerja berdasarkan <em>desired state</em>, yaitu kondisi yang kita inginkan dari sebuah sistem (<a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/">Kubernetes Documentation — Objects in Kubernetes</a>).</p><p>Bayangkan kita ingin menjalankan Nginx dengan tiga instance. Dengan cara konvensional, kita menjalankan tiga container secara manual lalu memastikan ketiganya tetap hidup. Kalau salah satu berhenti, kitalah yang harus menyadarinya dan menjalankannya kembali.</p><p>Di Kubernetes, kita cukup menyatakan satu hal: aplikasi ini harus punya tiga replika. Sisanya menjadi tugas Kubernetes, yaitu terus menjaga agar kondisi aktual cluster selalu sama dengan kondisi yang kita nyatakan. Tugas kita bergeser dari menjaga aplikasi menjadi menulis pernyataan tentang aplikasi itu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n0ct_8ixXB3OTdV0cDOKUg.png" /><figcaption><em>Gambar 2. Desired State dan Reconciliation Loop.</em></figcaption></figure><p>Diagram ini sengaja disederhanakan. Dalam implementasinya, controller membaca object lewat API Server, mengamati perubahannya, lalu bertindak lewat API yang sama, sementara scheduler dan kubelet menjalankan perannya masing-masing dalam menempatkan dan mengoperasikan workload.</p><p>Proses membandingkan kondisi yang diinginkan dengan kondisi aktual, terus-menerus tanpa henti, dikenal sebagai <em>reconciliation loop</em>. Inilah mesin di balik self-healing yang akan kita lihat nanti saat sebuah objek dihapus (Kubernetes Documentation — Controllers).</p><p>Konsep ini berkaitan langsung dengan etcd yang kita bahas di artikel sebelumnya. Saat kita membuat sebuah Kubernetes Object lewat API Server, representasinya disimpan secara persisten di etcd. Namun, etcd hanya menyediakan penyimpanan state: ia tidak menjalankan aplikasi dan tidak melakukan self-healing (Kubernetes Documentation — Kubernetes Components).</p><p>Yang mengamati dan merekonsiliasi selisih antara desired state dan actual state adalah controller Kubernetes. Singkatnya, etcd mengingat apa yang kita inginkan, dan controller memastikan hal itu terjadi.</p><h4><strong>2. Apa itu Kubernetes Object?</strong></h4><p>Kubernetes Object adalah representasi dari sesuatu yang ingin kita kelola di dalam cluster, disimpan sebagai pernyataan <em>desired state</em> yang terus dijaga oleh Kubernetes (<a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/">Kubernetes Documentation — Objects in Kubernetes</a>).</p><p>Object bisa mendeskripsikan banyak hal, mulai dari aplikasi yang dijalankan, jumlah replika, konfigurasi jaringan, hingga kebutuhan penyimpanan. Beberapa contohnya:</p><ul><li><strong>Pod:</strong> satu atau lebih container yang berjalan bersama.</li><li><strong>Deployment:</strong> bagaimana sekumpulan Pod harus dijalankan dan diperbarui.</li><li><strong>Service:</strong> cara mengakses sekumpulan Pod lewat jaringan.</li><li><strong>ConfigMap:</strong> konfigurasi aplikasi yang disimpan terpisah dari image.</li><li><strong>PersistentVolumeClaim:</strong> permintaan storage.</li></ul><p>Pada artikel bagian pertama ini, kita fokus pada object yang berhubungan dengan lifecycle aplikasi: bagaimana aplikasi dijalankan, dijaga, dan diperbarui. Object untuk jaringan, konfigurasi, dan storage kita bahas di bagian kedua.</p><h4><strong>3. Anatomi sebuah manifest</strong></h4><p>Object biasanya ditulis dalam file YAML yang disebut <em>manifest</em>. Hampir semuanya punya empat bagian utama:</p><pre>apiVersion: v1          # versi API yang dipakai object ini <br>kind: Pod               # jenis object <br>metadata:               # identitas: nama, namespace, label <br>  name: contoh <br>spec:                   # desired state: apa yang kita inginkan <br>  containers: <br>    - name: app <br>      image: nginx:1.25 </pre><p>Pada contoh di atas, kita mendeklarasikan sebuah Pod bernama contoh yang menjalankan satu container dengan image Nginx versi 1.25. Menariknya, kita tidak menentukan di worker node mana Pod itu berjalan: Kubernetes Scheduler yang memilih node yang memenuhi kebutuhannya (Kubernetes Documentation — Kubernetes Components). Ada satu bagian lagi yang tidak tampak di manifest, yaitu status. Field ini tidak kita tulis, melainkan diisi oleh Kubernetes berdasarkan kondisi aktual resource, dan selisih antara spec (yang kita inginkan) dengan status (yang sebenarnya terjadi) inilah yang menjadi dasar mekanisme reconciliation tadi (<a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/">Kubernetes Documentation — Objects in Kubernetes</a>).</p><h4><strong>4. Namespace, Label, dan Selector: Mengorganisasi Resource Kubernetes</strong></h4><p>Tiga konsep ini terdengar sederhana, tapi akan terus muncul di setiap object lain, jadi kita bahas di awal.</p><p><strong>Namespace</strong> adalah pemisah logis di dalam satu cluster. Anggap saja seperti folder: kita bisa punya namespace dev, staging, dan prod di cluster yang sama, dan nama object di tiap namespace tidak saling bentrok (<a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/">Kubernetes Documentation — Namespaces</a>).</p><p>Kita mulai dengan melihat namespace yang sudah ada, lalu membuat namespace bernama lab untuk seluruh eksperimen di artikel ini:</p><pre>root@cntrl1ab01:~# kubectl get ns<br>NAME              STATUS   AGE<br>default           Active   15d<br>kube-node-lease   Active   15d<br>kube-public       Active   15d<br>kube-system       Active   15d<br>root@cntrl1ab01:~# kubectl create ns lab<br>namespace/lab created<br>root@cntrl1ab01:~# kubectl get ns lab<br>NAME   STATUS   AGE<br>lab    Active   19s<br>root@cntrl1ab01:~#</pre><p>Di cluster standar kita akan menemukan default, kube-system, kube-public, dan kube-node-lease. Dengan namespace lab, resource belajar kita tidak bercampur dengan resource sistem di kube-system.</p><p><strong>Label</strong> adalah pasangan key-value yang kita tempelkan pada object, misalnya app: web atau tier: frontend. Label tidak mengubah perilaku object, hanya menjadi penanda (<a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/">Kubernetes Documentation — Labels and Selectors</a>).</p><p>Sebagai contoh, kita tempelkan label environment=learning pada namespace lab, lalu lihat hasilnya:</p><pre>root@cntrl1ab01:~# kubectl label namespace lab environment=learning<br>namespace/lab labeled<br>root@cntrl1ab01:~# kubectl get namespaces --show-labels<br>NAME              STATUS   AGE    LABELS<br>default           Active   15d    kubernetes.io/metadata.name=default<br>kube-node-lease   Active   15d    kubernetes.io/metadata.name=kube-node-lease<br>kube-public       Active   15d    kubernetes.io/metadata.name=kube-public<br>kube-system       Active   15d    kubernetes.io/metadata.name=kube-system<br>lab               Active   118s   environment=learning,kubernetes.io/metadata.name=lab<br>root@cntrl1ab01:~#</pre><p><strong>Selector</strong> adalah cara memilih object berdasarkan labelnya. Di sinilah label menjadi penting: Deployment memakai selector untuk mengenali Pod miliknya, dan Service (di bagian 2) memakai selector untuk tahu ke Pod mana trafik harus dikirim (<a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/">Kubernetes Documentation — Labels and Selectors</a>).</p><p>Sekarang kita pilih namespace tadi dengan selector (-l adalah singkatan dari — selector):</p><pre>root@cntrl1ab01:~# kubectl get namespaces -l environment=learning<br>NAME   STATUS   AGE<br>lab    Active   4m41s<br>root@cntrl1ab01:~#</pre><p>Perintah ini hanya menampilkan namespace yang punya label environment=learning.</p><h4><strong>5. Pod: Unit Terkecil yang Menjalankan Aplikasi</strong></h4><p>Setelah punya namespace lab, saatnya menjalankan aplikasi pertama. Unit terkecil yang bisa dibuat dan dijadwalkan di Kubernetes untuk menjalankan container adalah <strong>Pod </strong>(Kubernetes Documentation — Pods).</p><p>Satu hal yang penting: <strong>Pod bukanlah container</strong>. Pod adalah abstraksi yang membungkus satu atau beberapa container yang dijalankan bersama. Container di dalam Pod yang sama berbagi network namespace, sehingga memakai alamat IP yang sama dan bisa berkomunikasi lewat localhost, serta bisa mengakses volume bersama jika dikonfigurasi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qRW70fvdurLaVHiRmsPO1g.png" /><figcaption>Gamar 3. <em>Hubungan Pod dan Container</em></figcaption></figure><p>Dalam kebanyakan kasus, satu Pod cukup berisi satu container aplikasi. Namun, Kubernetes juga mendukung pola <em>multi-container Pod</em>, misalnya container utama yang didampingi <em>sidecar</em> untuk pengolahan log atau proxy. Pola sidecar layak dibahas di artikel tersendiri.</p><p><strong>Menjalankan Pod Nginx</strong></p><pre>apiVersion: v1 <br>kind: Pod <br>metadata: <br>  name: nginx-demo <br>  namespace: lab <br>  labels: <br>    app: nginx <br>    environment: learning <br>spec: <br>  containers: <br>    - name: nginx <br>      image: nginx:1.27 <br>      ports: <br>        - containerPort: 80 <br>  restartPolicy: Always </pre><p>Perhatikan bagian labels: Pod ini kita beri label app: nginx, yang nanti dipakai object lain untuk mengenalinya. Sekarang terapkan manifest-nya:</p><pre>kubectl apply -f nginx-pod.yaml </pre><p>Manifest ini diterima oleh API Server. Selanjutnya Scheduler menentukan node untuk Pod, dan kubelet di node terpilih meminta container runtime menjalankan container Nginx. Untuk melihat hasilnya:</p><pre>root@cntrl1ab01:~# kubectl get pods -n lab -o wide <br>NAME         READY   STATUS    RESTARTS   AGE   NODE <br>nginx-demo   1/1     Running   0          20s   srvwrk1ab01</pre><p>Nama node di output akan mengikuti hostname worker di cluster kita. Output ini menunjukkan Pod sudah berjalan, tetapi belum menjelaskan bagaimana Pod itu dibuat. Untuk melihat detailnya:</p><pre>root@cntrl1ab01:~# kubectl describe pod nginx-demo -n lab </pre><p>Perintah describe menampilkan antara lain node tempat Pod berjalan, image yang dipakai, IP Pod, status container, dan event selama proses pembuatan. Bagian Events paling menarik karena memperlihatkan tahapan yang dilalui Pod, dari scheduling sampai container berhasil dijalankan, sesuai alur yang tadi kita bahas.</p><p>Untuk melihat log aplikasi:</p><pre>root@cntrl1ab01:~# kubectl logs nginx-demo -n lab </pre><p><strong>Pod yang dihapus tidak kembali</strong></p><p>Sekarang kita hapus Pod-nya:</p><pre>root@cntrl1ab01:~# kubectl delete pod nginx-demo -n lab<br>root@cntrl1ab01:~# kubectl get pods -n lab<br>root@cntrl1ab01:~#</pre><p>Pod hilang, dan <strong>tidak ada yang membuatnya kembali</strong>. Ini poin penting. Pod yang dibuat sendirian tidak punya “penjaga”. Kalau node-nya mati atau Pod-nya terhapus, selesai urusannya. Untuk aplikasi sungguhan, kita butuh sesuatu yang menjaga agar Pod tetap ada (<a href="https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/">Kubernetes Documentation — Pod Lifecycle</a>).</p><h4><strong>6. ReplicaSet: Bagaimana Kubernetes Menjaga Jumlah Pod?</strong></h4><p>Bayangkan aplikasi kita harus selalu berjalan dengan tiga replika. Kalau salah satu Pod gagal atau dihapus, kita berharap Kubernetes membuat Pod pengganti sehingga jumlahnya kembali menjadi tiga. Di sinilah <strong>ReplicaSet</strong> berperan.</p><p>ReplicaSet adalah controller yang memastikan jumlah Pod yang cocok dengan selector-nya selalu sesuai dengan jumlah replika yang kita deklarasikan (<a href="https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/">Kubernetes Documentation — ReplicaSet</a>). Misalnya:</p><pre>spec: <br>  replicas: 3 </pre><p>Dengan deklarasi itu, kita menginginkan tiga Pod. ReplicaSet mengamati berapa banyak Pod yang cocok dengan selector dan berada dalam pengelolaannya: kalau kurang dari tiga, ia membuat Pod baru, dan kalau lebih dari tiga, ia menghapus kelebihannya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZlvrOoL3VsJdYVsboOOoEg.png" /><figcaption>Gambar 4. <em>Mekanisme ReplicaSet</em></figcaption></figure><p>Pada ilustrasi di atas, ReplicaSet tidak menghidupkan kembali Pod B yang sudah dihapus. Ia membuat Pod baru, yaitu Pod D, sebagai pengganti. Pod baru ini punya identitas sendiri dan bisa saja dijadwalkan di node yang berbeda.</p><p>Inilah salah satu bentuk <em>self-healing</em> di Kubernetes, sekaligus penerapan reconciliation loop yang kita bahas di awal.</p><p>Namun, fokus ReplicaSet hanyalah menjaga jumlah Pod. Untuk kebutuhan seperti pembaruan versi aplikasi secara bertahap dan rollback, Kubernetes menyediakan abstraksi yang lebih tinggi bernama <strong>Deployment</strong>. Kita akan melihat ReplicaSet bekerja langsung di praktikum Deployment berikutnya.</p><h4><strong>7. Deployment: object yang paling sering dipakai</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BTIjGJ4E-7R0L4WEOxNRug.png" /><figcaption>Gambar 5. Hierarti Deployment.</figcaption></figure><p><strong>Deployment</strong> adalah object yang mengelola ReplicaSet, dan ReplicaSet mengelola Pod. Kenapa butuh lapisan tambahan di atas ReplicaSet? Karena Deployment menambahkan kemampuan yang paling kita perlukan untuk aplikasi nyata: <strong>scaling, rolling update, dan rollback </strong>(<a href="https://kubernetes.io/docs/concepts/workloads/controllers/deployment/">Kubernetes Documentation — Deployment</a>). File deployment.yaml</p><pre>apiVersion: apps/v1 <br>kind: Deployment <br>metadata: <br>  name: web <br>  namespace: lab <br>spec: <br>  replicas: 3 <br>  selector: <br>    matchLabels: <br>      app: web <br>  template: <br>    metadata: <br>      labels: <br>        app: web <br>    spec: <br>      containers: <br>        - name: nginx <br>          image: nginx:1.25 <br>          ports: <br>            - containerPort: 80 </pre><p>Perhatikan bagian selector dan template.metadata.labels: labelnya harus sama (app: web). Itulah cara Deployment mengenali Pod miliknya. Bagian template adalah cetakan Pod yang akan dibuat. Jalanan deploymentnya.</p><pre>root@cntrl1ab01:~# kubectl apply -f deployment.yaml<br>deployment.apps/web created<br>root@cntrl1ab01:~# kubectl get deployment,replicaset,pods -n lab<br>NAME                  READY   UP-TO-DATE   AVAILABLE   AGE<br>deployment.apps/web   3/3     3            3           27s<br><br>NAME                             DESIRED   CURRENT   READY   AGE<br>replicaset.apps/web-57794f8f99   3         3         3       27s<br><br>NAME                       READY   STATUS    RESTARTS   AGE<br>pod/web-57794f8f99-7p7sr   1/1     Running   0          27s<br>pod/web-57794f8f99-dvsd6   1/1     Running   0          27s<br>pod/web-57794f8f99-xwhbt   1/1     Running   0          27s<br>root@cntrl1ab01:~/article-lab#</pre><p>Sekarang hierarki di gambar tadi bisa dilihat langsung: satu Deployment, satu ReplicaSet, dan tiga Pod.</p><p><strong>Self-healing: Pod dihapus, Pod baru muncul</strong></p><p>Ingat eksperimen tadi, ketika Pod yang kita hapus hilang begitu saja dan tidak ada yang membuatnya kembali? Sekarang kita ulangi skenario yang sama, tetapi kali ini Pod-nya dikelola Deployment. Kita tidak hanya melihat hasil akhirnya, tetapi mengamati prosesnya secara langsung.</p><p>Buka dua terminal. Di terminal pertama, pantau perubahan Pod secara real time (-w berarti <em>watch</em>):</p><pre>root@cntrl1ab01:~# kubectl get pods -n lab -w</pre><p>Di terminal kedua, pilih salah satu Pod dari output tadi (ganti &lt;nama-pod&gt; sesuai nama di cluster kamu), lalu hapus:</p><pre>root@cntrl1ab01:~# kubectl delete pod pod/web-57794f8f99-7p7sr -n lab</pre><p>Di terminal pertama, urutan kejadiannya kira-kira seperti ini</p><pre>NAME                   READY   STATUS              RESTARTS   AGE<br>web-57794f8f99-7p7sr   1/1     Running             0          2m<br>web-57794f8f99-dvsd6   1/1     Running             0          2m<br>web-57794f8f99-xwhbt   1/1     Running             0          2m<br>web-57794f8f99-7p7sr   1/1     Terminating         0          2m20s<br>web-57794f8f99-hn4kc   0/1     Pending             0          0s<br>web-57794f8f99-hn4kc   0/1     ContainerCreating   0          0s<br>web-57794f8f99-hn4kc   1/1     Running             0          2s</pre><p>Ada tiga hal yang layak diperhatikan:</p><ol><li><strong>Pod pengganti muncul hampir bersamaan.</strong> Pod baru sudah dibuat sebelum Pod lama selesai berstatus Terminating. Kita tidak perlu menunggu atau menjalankan perintah apa pun.</li><li><strong>Namanya berbeda.</strong> Pod web-57794f8f99-7p7sr tidak dihidupkan kembali. Yang muncul adalah Pod baru dengan nama baru (web-57794f8f99-hn4kc), dan seperti dijelaskan di bagian ReplicaSet, ia bisa saja dijadwalkan di node yang berbeda. Perhatikan juga bahwa awalan web-57794f8f99 tidak berubah, karena Pod pengganti dibuat oleh ReplicaSet yang sama.</li><li><strong>Jumlahnya kembali tiga.</strong> ReplicaSet mendeteksi selisih antara desired state (3 Pod) dan actual state (2 Pod), lalu membuat satu Pod untuk menutupnya. Itulah reconciliation loop yang kita bahas di awal, kini terlihat bekerja.</li></ol><h4>Scaling</h4><p>Mengubah jumlah replika cukup satu perintah:</p><pre>root@cntrl1ab01:~# kubectl scale deployment web --replicas=5 -n lab<br>deployment.apps/web scaled<br>root@cntrl1ab01:~# kubectl get pods -n lab<br>NAME                   READY   STATUS    RESTARTS   AGE<br>web-57794f8f99-dvsd6   1/1     Running   0          6m12s<br>web-57794f8f99-hn4kc   1/1     Running   0          3m48s<br>web-57794f8f99-r5m9x   1/1     Running   0          4s<br>web-57794f8f99-xwhbt   1/1     Running   0          6m12s<br>web-57794f8f99-zt8bj   1/1     Running   0          4s</pre><p>Sekarang coba, turunkan kembali replica nya ke-3? :)</p><p><strong>Rolling update dan rollback</strong></p><p>Bayangkan kita mau memperbarui aplikasi kita, let’s say nginx dari versi 1.25 ke 1.27 tanpa membuat aplikasi mati. By default Deployment melakukannya dengan <strong>rolling update</strong>: Pod baru dinaikkan sedikit demi sedikit sementara Pod lama diturunkan, sehingga selalu ada Pod yang melayani.</p><pre>root@cntrl1ab01:~# kubectl set image deployment/web nginx=nginx:1.27 -n lab<br>deployment.apps/web image updated<br>root@cntrl1ab01:~# kubectl rollout status deployment/web -n lab<br>Waiting for deployment &quot;web&quot; rollout to finish: 1 out of 3 new replicas have been updated...<br>Waiting for deployment &quot;web&quot; rollout to finish: 1 out of 3 new replicas have been updated...<br>Waiting for deployment &quot;web&quot; rollout to finish: 2 out of 3 new replicas have been updated...<br>Waiting for deployment &quot;web&quot; rollout to finish: 2 out of 3 new replicas have been updated...<br>Waiting for deployment &quot;web&quot; rollout to finish: 1 old replicas are pending termination...<br>Waiting for deployment &quot;web&quot; rollout to finish: 1 old replicas are pending termination...<br>deployment &quot;web&quot; successfully rolled out</pre><p>Perhatikan pesannya: jumlah replika baru naik bertahap (1, lalu 2, lalu 3), sementara replika lama baru diturunkan setelah pengganti siap. Itulah rolling update.</p><p>Sekarang lihat ReplicaSet-nya:</p><pre>root@cntrl1ab01:~# kubectl get replicaset -n lab<br>NAME             DESIRED   CURRENT   READY   AGE<br>web-57794f8f99   0         0         0       14m<br>web-6b8d9c7f5d   3         3         3       52s<br>root@cntrl1ab01:~#<br>root@cntrl1ab01:~# kubectl rollout history deployment/web -n lab<br>deployment.apps/web<br>REVISION  CHANGE-CAUSE<br>1         &lt;none&gt;<br>2         &lt;none&gt;</pre><p>da dua ReplicaSet. Yang lama (web-57794f8f99) jumlah Pod-nya 0 tetapi tidak dihapus, sedangkan yang baru (web-6b8d9c7f5d) mengelola ketiga Pod dengan Nginx 1.27. Kolom CHANGE-CAUSE berisi &lt;none&gt; karena kita tidak mencatat alasan perubahan lewat anotasi, dan itu normal.</p><p>Kalau versi baru ternyata bermasalah, kembali ke versi sebelumnya cukup dengan:</p><pre>root@cntrl1ab01:~# kubectl rollout undo deployment/web -n lab<br>deployment.apps/web rolled back<br>root@cntrl1ab01:~# kubectl get replicaset -n lab<br>NAME             DESIRED   CURRENT   READY   AGE<br>web-57794f8f99   3         3         3       15m<br>web-6b8d9c7f5d   0         0         0       1m40s<br>root@cntrl1ab01:~# kubectl rollout history deployment/web -n lab<br>deployment.apps/web<br>REVISION  CHANGE-CAUSE<br>2         &lt;none&gt;<br>3         &lt;none&gt;</pre><p>ReplicaSet lama sengaja tidak dihapus, dan dari sanalah Kubernetes bisa kembali dengan cepat. Sekarang web-57794f8f99 kembali berisi 3 Pod, dan yang baru turun ke 0. Revision 1 hilang dari history dan muncul sebagai revision 3, karena rollback dicatat sebagai revisi baru yang isinya sama dengan revisi sebelumnya.</p><blockquote><strong>Catatan:</strong> kubectl set image dipakai di sini supaya efeknya mudah terlihat. Di dunia nyata, perubahan sebaiknya dilakukan dengan mengedit file YAML lalu kubectl apply, supaya YAML tetap menjadi sumber kebenaran (single source of truth).</blockquote><h4>8. Tidak Semua Aplikasi Cocok dengan Deployment: Mengenal StatefulSet, DaemonSet, dan Job</h4><p>Setelah mencoba Deployment, mungkin muncul pertanyaan: apakah semua aplikasi harus memakai Deployment? Jawabannya tidak. Deployment sangat cocok untuk workload <em>stateless</em>, yaitu aplikasi yang Pod-nya bisa diganti Pod lain tanpa butuh identitas tetap (<a href="https://kubernetes.io/docs/concepts/workloads/controllers/deployment/">Kubernetes Documentation — Deployment</a>). Untuk kebutuhan lain, Kubernetes menyediakan jenis workload berbeda. Di bagian ini kita kenali tiga yang paling umum, masing-masing dengan percobaan singkat.</p><p><strong>StatefulSet</strong></p><p>StatefulSet dipakai untuk aplikasi yang butuh identitas Pod yang stabil, urutan pengelolaan tertentu, atau hubungan storage yang konsisten, misalnya database seperti PostgreSQL atau aplikasi terdistribusi yang butuh identitas node tetap (<a href="https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/">Kubernetes Documentation — StatefulSet</a>). Berbeda dengan Deployment yang memberi nama Pod secara acak, StatefulSet memberi nama berurutan seperti db-0, db-1, dan seterusnya, serta dapat memakai persistent storage lewat <em>volume claim template</em>.</p><p>Perlu diingat, StatefulSet tidak otomatis membuat database menjadi High Availability. Replikasi, failover, dan konsistensi data tetap harus ditangani oleh aplikasi atau operator yang sesuai.</p><p>Untuk percobaan, kita pakai PostgreSQL. Storage belum kita pasang (dibahas di bagian 2), jadi percobaan ini sekaligus menunjukkan apa yang terjadi pada data tanpa storage persisten. Buat file statefulset.yaml:</p><pre>apiVersion: apps/v1<br>kind: StatefulSet<br>metadata:<br>  name: db<br>  namespace: lab<br>spec:<br>  serviceName: db<br>  replicas: 2<br>  selector:<br>    matchLabels:<br>      app: db<br>  template:<br>    metadata:<br>      labels:<br>        app: db<br>    spec:<br>      containers:<br>        - name: postgres<br>          image: postgres:16<br>          env:<br>            - name: POSTGRES_PASSWORD<br>              value: &quot;lab-only-password&quot;<br>          ports:<br>            - containerPort: 5432</pre><blockquote><strong>Catatan:</strong> password ditulis langsung di YAML hanya untuk keperluan lab. Di lingkungan production, nilai ini disimpan di Secret (Kubernetes Documentation — Secrets).</blockquote><p>Field serviceName merujuk ke <em>headless Service</em> yang akan kita bahas di bagian 2. Untuk percobaan ini, Pod tetap berjalan tanpa Service tersebut.</p><pre>root@cntrl1ab01:~# kubectl apply -f statefulset.yaml<br>statefulset.apps/db created<br>root@cntrl1ab01:~# kubectl get pods -n lab -l app=db<br>NAME   READY   STATUS    RESTARTS   AGE<br>db-0   1/1     Running   0          25s<br>db-1   1/1     Running   0          12s</pre><p>Perhatikan nama Pod-nya: db-0 dan db-1, berurutan, bukan nama acak seperti pada Deployment. Perhatikan juga AGE-nya: db-1 dibuat setelah db-0 siap. Itulah perilaku StatefulSet yang membuat Pod satu per satu sesuai urutan.</p><p>Sekarang kita isi data di db-0. Pertama, buat tabel:</p><pre>root@cntrl1ab01:~# kubectl exec -n lab db-0 -- psql -U postgres -c &quot;CREATE TABLE catatan (id serial, isi text);&quot;<br>CREATE TABLE</pre><p>Lalu isi satu baris data:</p><pre>root@cntrl1ab01:~# kubectl exec -n lab db-0 -- psql -U postgres -c &quot;INSERT INTO catatan (isi) VALUES (&#39;halo dari db-0&#39;);&quot;<br>INSERT 0 1</pre><p>Dan baca kembali isinya:</p><pre>root@cntrl1ab01:~# kubectl exec -n lab db-0 -- psql -U postgres -c &quot;SELECT * FROM catatan;&quot;<br> id |      isi<br>----+----------------<br>  1 | halo dari db-0<br>(1 row)</pre><p>Cek juga db-1. Tabel catatan tidak ada di sana, karena db-0 dan db-1 adalah dua instance PostgreSQL yang berdiri sendiri, bukan replikasi:</p><pre>root@cntrl1ab01:~# kubectl exec -n lab db-1 -- psql -U postgres -c &quot;SELECT * FROM catatan;&quot;<br>ERROR:  relation &quot;catatan&quot; does not exist<br>LINE 1: SELECT * FROM catatan;<br>                      ^<br>command terminated with exit code 1</pre><p>Inilah maksud paragraf sebelumnya: StatefulSet memberi identitas, bukan replikasi. Sekarang hapus db-0:</p><pre>root@cntrl1ab01:~# kubectl delete pod db-0 -n lab<br>pod &quot;db-0&quot; deleted</pre><p>Lalu lihat Pod-nya:</p><pre>root@cntrl1ab01:~# kubectl get pods -n lab -l app=db<br>NAME   READY   STATUS    RESTARTS   AGE<br>db-0   1/1     Running   0          9s<br>db-1   1/1     Running   0          2m4s</pre><p>Pod pengganti muncul dengan nama yang sama, db-0, sedangkan AGE-nya baru beberapa detik. Itulah identitas stabil StatefulSet: Pod-nya diganti, tetapi identitasnya tetap. Sekarang cek datanya:</p><pre>root@cntrl1ab01:~# kubectl exec -n lab db-0 -- psql -U postgres -c &quot;SELECT * FROM catatan;&quot;<br>ERROR:  relation &quot;catatan&quot; does not exist<br>LINE 1: SELECT * FROM catatan;<br>                      ^<br>command terminated with exit code 1</pre><p>Datanya hilang. Namanya tetap db-0, tetapi isinya kosong, karena data Postgres tersimpan di filesystem container yang ikut hilang bersama Pod lama. Identitas stabil saja tidak cukup untuk database. Kita juga butuh storage, dan itulah yang kita bahas di bagian 2 lewat PersistentVolumeClaim dan <em>volume claim template</em>.</p><p><strong>StatefulSet</strong></p><p><strong>DaemonSet</strong> dipakai ketika kita ingin menjalankan satu Pod di setiap node yang memenuhi kriteria tertentu, misalnya agent logging, monitoring, atau komponen pendukung infrastruktur (<a href="https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/">Kubernetes Documentation — DaemonSet</a>). Jika sebuah node baru bergabung ke cluster dan memenuhi aturannya, Kubernetes otomatis menjadwalkan Pod DaemonSet di node tersebut. Konsep ini juga relevan dengan pengelolaan GPU, karena sejumlah komponen pendukung GPU biasanya berjalan sebagai DaemonSet di GPU node. Buat file daemonset.yaml:</p><pre>apiVersion: apps/v1<br>kind: DaemonSet<br>metadata:<br>  name: node-agent<br>  namespace: lab<br>spec:<br>  selector:<br>    matchLabels:<br>      app: node-agent<br>  template:<br>    metadata:<br>      labels:<br>        app: node-agent<br>    spec:<br>      containers:<br>        - name: agent<br>          image: busybox:1.36<br>          command: [&quot;sh&quot;, &quot;-c&quot;, &quot;while true; do echo hello from $(hostname); sleep 30; done&quot;]</pre><p>Perhatikan bahwa tidak ada field replicas di manifest ini. Jumlah Pod ditentukan oleh jumlah node yang memenuhi syarat. Terapkan manifest-nya:</p><pre>root@cntrl1ab01:~# kubectl apply -f daemonset.yaml<br>daemonset.apps/node-agent created</pre><p>Lalu lihat outputnya.</p><pre>root@cntrl1ab01:~# kubectl get pods -n lab -l app=node-agent -o wide<br>NAME               READY   STATUS    RESTARTS   AGE   IP           NODE          NOMINATED NODE   READINESS GATES<br>node-agent-5xk7d   1/1     Running   0          18s   10.244.1.9   srvwrk1ab01   &lt;none&gt;           &lt;none&gt;<br>node-agent-q8t2m   1/1     Running   0          18s   10.244.2.7   srvwrk1ab02   &lt;none&gt;           &lt;none&gt;</pre><p>Perhatikan kolom NODE: ada satu Pod di setiap worker node (srvwrk1ab01 dan srvwrk1ab02), tanpa kita menentukan jumlah replika. Ketiga node control plane (srvcp1ab01 sampai srvcp1ab03) tidak ikut karena punya taint yang mencegah workload biasa dijadwalkan di sana (Kubernetes Documentation — Taints and Tolerations).</p><p>Kita juga bisa melihat DaemonSet-nya langsung:</p><pre>root@cntrl1ab01:~# kubectl get daemonset -n lab<br>NAME         DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE<br>node-agent   2         2         2       2            2           &lt;none&gt;          35s</pre><p>Angka DESIRED diisi Kubernetes berdasarkan jumlah node yang memenuhi syarat, bukan angka yang kita tulis. Kalau kita menambah worker baru, angka ini naik dan Pod-nya muncul sendiri di node itu.</p><p>Terakhir, pastikan agent-nya bekerja:</p><pre>root@cntrl1ab01:~# kubectl logs node-agent-5xk7d -n lab<br>hello from node-agent-5xk7d<br>hello from node-agent-5xk7d</pre><p>Hostname yang tercetak adalah nama Pod, bukan nama node, karena hostname dijalankan di dalam container.</p><h4><strong>Job dan Cronjob</strong></h4><p>Tidak semua aplikasi harus berjalan terus-menerus seperti web server. Ada workload yang hanya perlu menyelesaikan satu tugas lalu berhenti, misalnya proses batch, migrasi tertentu, atau pengolahan data satu kali. Untuk kebutuhan itu Kubernetes menyediakan <strong>Job </strong>(<a href="https://kubernetes.io/docs/concepts/workloads/controllers/job/">Kubernetes Documentation — Job</a>). Sementara <strong>CronJob</strong> menjalankan Job sesuai jadwal, misalnya backup database setiap malam atau pembersihan data secara berkala.</p><p>Untuk Job dan CronJob, kita cukup memakai imperative-command dengan perintah kubectl create:</p><pre>root@cntrl1ab01:~# kubectl create job hello-job --image=busybox:1.36 -n lab -- echo &quot;Halo dari Job&quot;<br>job.batch/hello-job created</pre><pre>root@cntrl1ab01:~# kubectl get jobs -n lab<br>NAME        STATUS     COMPLETIONS   DURATION   AGE<br>hello-job   Complete   1/1           4s         9s</pre><pre>root@cntrl1ab01:~# kubectl get pods -n lab<br>NAME                   READY   STATUS      RESTARTS   AGE<br>db-0                   1/1     Running     0          42m<br>db-1                   1/1     Running     0          44m<br>hello-job-x7k2p        0/1     Completed   0          12s<br>node-agent-5xk7d       1/1     Running     0          31m<br>node-agent-q8t2m       1/1     Running     0          31m<br>web-57794f8f99-b4n8c   1/1     Running     0          19m<br>web-57794f8f99-hn4kc   1/1     Running     0          19m<br>web-57794f8f99-xwhbt   1/1     Running     0          19m</pre><p>Pod milik Job akan berstatus Completed: tugasnya selesai, lalu berhenti dan tidak dijalankan ulang. Sekarang kita coba CronJob dengan jadwal setiap menit:</p><pre>root@cntrl1ab01:~# kubectl create cronjob hello-cron --image=busybox:1.36 --schedule=&quot;*/1 * * * *&quot; -n lab -- echo &quot;Halo dari CronJob&quot;<br>cronjob.batch/hello-cron created</pre><pre>root@cntrl1ab01:~# kubectl get cronjob -n lab<br>NAME         SCHEDULE      TIMEZONE   SUSPEND   ACTIVE   LAST SCHEDULE   AGE<br>hello-cron   */1 * * * *   &lt;none&gt;     False     0        &lt;none&gt;          6s</pre><pre>root@cntrl1ab01:~# kubectl get jobs -n lab<br>NAME        STATUS     COMPLETIONS   DURATION   AGE<br>hello-job   Complete   1/1           4s         1m</pre><p>Tunggu sekitar 1–2 menit lalu jalankan kubectl get jobs -n lab lagi: CronJob membuat Job baru setiap menit sesuai jadwalnya.</p><pre>root@cntrl1ab01:~# kubectl get jobs -n lab<br>NAME                  STATUS     COMPLETIONS   DURATION   AGE<br>hello-cron-29881512   Complete   1/1           3s         62s<br>hello-cron-29881513   Complete   1/1           3s         2s<br>hello-job             Complete   1/1           4s         2m10s</pre><p>Setelah selesai mencoba, hapus supaya tidak terus membuat Job baru:</p><pre>root@cntrl1ab01:~# kubectl delete cronjob hello-cron -n lab<br>cronjob.batch &quot;hello-cron&quot; deleted</pre><p>Nilai &quot;*/1 * * * *&quot; pada --schedule tadi adalah <strong>jadwal dalam format cron</strong>: lima kolom yang dipisahkan spasi, dibaca dari kiri ke kanan.</p><pre>*  *  *  *  *<br>|  |  |  |  |<br>|  |  |  |  +-- hari dalam minggu (0-6, 0 = Minggu)<br>|  |  |  +----- bulan (1-12)<br>|  |  +-------- tanggal dalam bulan (1-31)<br>|  +----------- jam (0-23)<br>+-------------- menit (0-59)</pre><p>Setiap kolom bisa diisi angka, atau karakter khusus: * berarti setiap nilai, , untuk daftar nilai (1,15), - untuk rentang (1-5), dan / untuk interval (*/5 berarti setiap 5). Beberapa contoh:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z4yEeuLSq2_0iZA-non3Xg.png" /><figcaption>Tabel 1. Contoh Ekspresi Jadwal pada CronJob</figcaption></figure><p>Untuk memeriksa ekspresi cron sebelum dipakai, <a href="https://crontab.guru/">crontab.guru</a> membantu menerjemahkannya ke bahasa manusia, dan referensi resminya ada di <a href="https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/">dokumentasi CronJob Kubernetes</a>. Perlu diingat, jadwal dihitung berdasarkan zona waktu kube-controller-manager (umumnya UTC), kecuali kita menentukan field spec.timeZone (<a href="https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/">Kubernetes Documentation — CronJob</a>).</p><h4><strong>9. Rangkuman: Kapan Menggunakan Masing-Masing Workload?</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7AUA20qqdyX9aEdjAt6rjQ.png" /><figcaption>Tabel 2. Perbandingan Workload Object dan Kegunaannya.</figcaption></figure><p>Pemilihan workload object sebaiknya mengikuti karakteristik aplikasi, bukan hanya karena satu object lebih mudah digunakan daripada object lainnya (<a href="https://kubernetes.io/docs/concepts/workloads/">Kubernetes Documentation — Workloads</a>).</p><p>Sekarang aplikasi kita sudah berjalan dan terjaga. Tapi masih ada pertanyaan yang belum terjawab:</p><ul><li>Bagaimana Pod-Pod itu bisa diakses, baik dari dalam maupun luar cluster?</li><li>Bagaimana menyimpan data sensitif seperti password PostgreSQL tanpa menuliskannya langsung di YAML?</li><li>Dan kenapa data PostgreSQL di db-0 hilang padahal namanya tetap sama? Bagaimana data bisa bertahan ketika Pod diganti?</li></ul><p>Jawabannya ada di bagian kedua: <strong>Service, Ingress, ConfigMap, Secret, dan storage</strong>.</p><h4>Referensi</h4><ul><li><a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/">Kubernetes Documentation — Objects in Kubernetes</a></li><li><a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/">Kubernetes Documentation — Namespaces</a></li><li><a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/">Kubernetes Documentation — Labels and Selectors</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/">Kubernetes Documentation — Pod Lifecycle</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/">Kubernetes Documentation — ReplicaSet</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/controllers/deployment/">Kubernetes Documentation — Deployment</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/">Kubernetes Documentation — StatefulSet</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/">Kubernetes Documentation — DaemonSet</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/controllers/job/">Kubernetes Documentation — Job</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/">Kubernetes Documentation — CronJob</a></li><li><a href="https://kubernetes.io/docs/concepts/workloads/">Kubernetes Documentation — Workloads</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=706736d9abaf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Membangun Kubernetes Cluster dengan Talos Linux: Memahami ETCD, Scaling, dan High Availability]]></title>
            <link>https://medium.com/@rendinicolasm/membangun-kubernetes-cluster-dengan-talos-linux-memahami-etcd-scaling-dan-high-availability-ff8d5f7a6814?source=rss-f5e3249994ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff8d5f7a6814</guid>
            <category><![CDATA[ha]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[talos-linux]]></category>
            <dc:creator><![CDATA[mahendrarendi]]></dc:creator>
            <pubDate>Sun, 18 Oct 2026 05:12:58 GMT</pubDate>
            <atom:updated>2026-10-18T05:12:58.024Z</atom:updated>
            <content:encoded><![CDATA[<p>Pada artikel sebelumnya, <a href="https://medium.com/@rendinicolasm/mengelola-server-lewat-api-mengenal-talos-linux-untuk-infrastruktur-kubernetes-90f2da9f91e4">Mengelola Server Lewat API: Mengenal Talos Linux untuk Infrastruktur Kubernetes</a>, saya membahas bagaimana Talos Linux menawarkan pendekatan berbeda dalam mengelola sistem operasi untuk Kubernetes.</p><p>Tidak ada SSH sebagai antarmuka administrasi standar, tidak ada pola instalasi package seperti pada Linux server konvensional, dan hampir seluruh operasi sistem dilakukan melalui API menggunakan “talosctl.”</p><p>Namun, setelah Talos Linux berhasil dijalankan, muncul pertanyaan berikutnya:</p><blockquote><strong>Bagaimana beberapa mesin Talos membentuk sebuah Kubernetes cluster, dan apa yang sebenarnya membuat cluster tersebut mampu bertahan ketika salah satu komponennya mengalami kegagalan?</strong></blockquote><p>Untuk menjawabnya, saya membangun sebuah lab Kubernetes di Cloudeka Deka Flexi FX2 secara bertahap.</p><p>Saya tidak langsung membuat cluster dengan lima node. Eksperimen dimulai dari satu control plane, dilanjutkan dengan penambahan dua control plane, kemudian dua worker.</p><p>Pendekatan tersebut memungkinkan saya mengamati perubahan perilaku Kubernetes dan etcd setiap kali sebuah node baru bergabung.</p><p>Tulisan ini bukan tutorial instalasi langkah demi langkah. Seluruh konfigurasi, script, dan prosedur teknis tersedia di <a href="https://github.com/mahendrarendi/talos-lab/releases/tag/v0.1.0">repository GitHub talos-lab.</a></p><p>Artikel ini lebih berfokus pada apa yang terjadi di balik proses bootstrap, bagaimana cluster berkembang, dan mengapa sejumlah node yang berstatus Ready belum tentu menjamin High Availability.</p><h4><strong>Dari Talos OS Menuju Kubernetes Cluster</strong></h4><p>Pada eksperimen sebelumnya, saya berhasil menjalankan Talos Linux melalui Custom Image di Cloudeka FX2. Node sudah memiliki hostname, IP address, network connectivity, dan dapat dikelola menggunakan <em>talosctl</em>. Namun, ada satu perbedaan mendasar antara mesin Talos yang sudah berjalan dengan mesin yang telah menjadi anggota Kubernetes cluster.</p><p>Ketika Talos berada dalam Maintenance Mode, sistem operasi sudah dapat diakses untuk provisioning, tetapi cluster Kubernetes belum terbentuk. Untuk mengubah kondisi tersebut, Talos membutuhkan machine configuration yang mendefinisikan bagaimana mesin akan berpartisipasi dalam Kubernetes. Konfigurasi tersebut mencakup identitas cluster, peran mesin, konfigurasi jaringan, serta berbagai pengaturan yang diperlukan oleh komponen Kubernetes. Setelah konfigurasi diterapkan, Talos mulai menyiapkan layanan seperti container runtime dan kubelet. Pada node control plane, proses ini juga melibatkan komponen Kubernetes serta etcd (<a href="https://docs.siderolabs.com/talos/v1.14/learn-more/control-plane">Talos: Control Plane</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pen0qtnDmrzFSwB5qQ25qw.png" /><figcaption>Gambar 1. Workflow Bootsrap Kubernetes.</figcaption></figure><h4><strong>Mengapa Kubernetes membutuhkan bootstrap?</strong></h4><p>Bootstrap merupakan proses inisialisasi pertama untuk membentuk cluster etcd baru. etcd berfungsi sebagai penyimpanan key-value terdistribusi yang menyimpan state penting Kubernetes, termasuk berbagai objek yang dikelola melalui Kubernetes API. Tanpa backend state yang tersedia, Kubernetes API server tidak dapat menjalankan fungsi pengelolaan cluster secara normal.</p><p>Dalam Talos, bootstrap etcd dilakukan satu kali ketika membentuk cluster baru. Ketika control plane tambahan bergabung, node-node tersebut tidak melakukan bootstrap ulang, melainkan bergabung dengan cluster yang sudah ada. Prinsip tersebut menjadi sangat penting ketika cluster mulai diperbesar.</p><p>Referensi: <a href="https://docs.siderolabs.com/talos/v1.14/learn-more/control-plane">Talos Linux — Control Plane</a> dan <a href="https://kubernetes.io/docs/concepts/overview/components/">Kubernetes — Components</a>.</p><h4><strong>Arsitektur Lab: Kubernetes di Cloudeka FX2</strong></h4><p>Saya menggunakan Cloudeka Deka Flexi FX2 sebagai lingkungan virtualisasi untuk menjalankan mesin-mesin Talos. Terdapat satu server administrasi bernama <em>srvcntrl1ab01</em> yang digunakan untuk mengoperasikan cluster melalui <em>talosctl</em> dan <em>kubectl.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nNcPXRt5SuCjU6G-PTDumA.png" /><figcaption>Gambar 2. Arsitektur Lab</figcaption></figure><p>Ketiga control plane menyediakan komponen pengelolaan Kubernetes, sedangkan worker berfungsi sebagai tempat menjalankan aplikasi. Setiap control plane dalam desain Talos ini juga berpartisipasi sebagai anggota etcd (<a href="https://kubernetes.io/docs/concepts/architecture/">Kubernetes: Cluster Architecture</a>).</p><p>Hal yang menarik adalah pemisahan dua aspek availability: redundansi komponen Kubernetes dan ketersediaan endpoint yang digunakan untuk mengakses komponen tersebut.</p><p>Karena itu, desain lab ini tidak berhenti pada tiga control plane. Agar Kubernetes API tetap dapat diakses ketika salah satu control plane gagal, endpoint-nya perlu berupa alamat bersama, yaitu Virtual IP (VIP), bukan IP milik satu control plane.</p><p>Diagram berikut memperlihatkan bagaimana VIP ditempatkan di depan ketiga control plane. Cara kerja VIP, batasannya, dan perbandingannya dengan load balancer saya bahas pada bagian Virtual IP.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3HXkTkUEM8o0iRGzFZ1GWw.png" /><figcaption>Gambar 3. Arsitektur VIP dalam Kubernetes.</figcaption></figure><p><strong>Struktur Repository dan Declarative Configuration</strong></p><p>Salah satu prinsip penting Talos Linux adalah pengelolaan sistem berdasarkan konfigurasi deklaratif.</p><p>Prinsip ini saya terapkan dengan menyimpan konfigurasi cluster dalam repository GitHub yang berisi template, patch, secrets, dan script untuk menghasilkan konfigurasi setiap node.</p><p>Struktur repository secara konseptual terdiri dari:</p><pre>talos-lab/ <br>├── .env.example <br>├── cluster.yaml <br>├── secrets.yaml <br>├── patches/ <br>├── scripts/ <br>│   └── render.sh <br>└── _out/ </pre><p>Struktur di atas adalah tata letak folder repository talos-lab. Folder _out berisi file hasil generate, yaitu machine configuration khusus node yang dihasilkan oleh scripts/render.sh (<a href="https://github.com/mahendrarendi/talos-lab/releases/tag/v0.1.0">Repository talos-lab</a>).</p><p>Dalam pendekatan ini, semua node menggunakan identitas cluster yang sama, tetapi masing-masing mempunyai konfigurasi mesin yang sesuai dengan rolenya.</p><p>Sebagai contoh, control plane dan worker memiliki tanggung jawab yang berbeda, tetapi keduanya tetap menjadi anggota cluster Kubernetes yang sama.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6UWOPcPxNG8Vb2sYjcKWlw.png" /><figcaption>Gambar 4. Scope of worfk kubernetes.</figcaption></figure><p><strong>Mengapa satu identitas cluster penting?</strong></p><p>Dalam Talos Linux, setiap node yang bergabung ke Kubernetes harus menggunakan <strong>identitas dan kredensial cluster yang konsisten</strong>. Identitas ini mencakup Certificate Authority (CA), token, dan secrets yang digunakan oleh Talos, Kubernetes, serta etcd.</p><p>Seluruh kredensial tersebut dihasilkan melalui talosctl gen secrets dan disimpan dalam secrets.yaml.</p><p>Ada dua prinsip penting:</p><ul><li><strong>Satu cluster, satu secrets bundle.</strong> CP02, CP03, dan worker menggunakan secrets yang sama dengan CP01 agar dapat bergabung ke cluster yang sudah ada.</li><li><strong>Generate secrets hanya sekali saat membuat cluster.</strong> Membuat secrets baru untuk node tambahan dapat menyebabkan ketidakcocokan identitas dan kegagalan proses join.</li></ul><blockquote><strong>Declarative configuration membantu menjaga konsistensi, tetapi perubahan tetap harus divalidasi sebelum diterapkan.</strong></blockquote><p>Referensi: <a href="https://docs.siderolabs.com/talos/v1.14/configure-your-talos-cluster/system-configuration/reproducible-machine-configuration">Talos — Reproducible Machine Configuration</a>.</p><h4>Flow Setup: Satu Control Plane hingga Lima Node</h4><p>Saya membagi pembangunan cluster menjadi tiga fase.</p><p>Tujuannya bukan memperlambat instalasi, tetapi memberikan kesempatan untuk memahami bagaimana cluster berubah ketika jumlah node bertambah.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MSZrr_bCiRB6L58zhQc0lg.png" /><figcaption>Gambar 5. Flow Setup Lab.</figcaption></figure><p><strong>Fase Pertama — Membangun Control Plane Pertama</strong></p><p>Tahap pertama dimulai dengan satu node Talos Linux yang masih berada dalam <em>Maintenance Mode</em>. Pada kondisi ini, sistem operasi sudah berjalan dan dapat diakses melalui Talos API, tetapi belum tergabung dalam Kubernetes cluster. (<a href="https://docs.siderolabs.com/talos/v1.14/getting-started/getting-started">Talos — Getting Started</a>)</p><p>Untuk membentuk cluster, <strong>machine configuration</strong> diterapkan untuk mendefinisikan identitas cluster, role node, jaringan, serta konfigurasi Kubernetes. Talos kemudian mempersiapkan komponen seperti container runtime, kubelet, dan control plane. (<a href="https://docs.siderolabs.com/talos/v1.14/learn-more/control-plane">Talos — Control Plane</a>)</p><p>Tahap berikutnya adalah <strong>bootstrap etcd</strong>, yaitu proses inisialisasi distributed key-value store yang menyimpan state Kubernetes. Bootstrap hanya dilakukan <strong>satu kali pada control plane pertama</strong>. Node berikutnya akan bergabung ke cluster yang sudah terbentuk. (<a href="https://docs.siderolabs.com/talos/v1.14/getting-started/getting-started">Talos — Bootstrapping</a>)</p><p><strong><em>Implementasi dan Verifikasi</em></strong></p><p>Berikut alur konfigurasi CP01 hingga verifikasi Kubernetes:</p><pre># Konfigurasi Talos API endpoint <br>talosctl config endpoint &lt;CP1_IP&gt; <br>talosctl config node &lt;CP1_IP&gt; <br> <br># Terapkan machine configuration <br>talosctl apply-config --insecure \ <br>  -n &lt;CP1_IP&gt; -f _out/&lt;cp1&gt;.yaml <br> <br># Verifikasi Talos API terautentikasi <br>talosctl version <br> <br># Bootstrap etcd (hanya sekali) <br>talosctl bootstrap <br> <br># Ambil kubeconfig Kubernetes <br>talosctl kubeconfig <br> <br># Verifikasi cluster <br>talosctl service etcd <br>talosctl etcd members <br>talosctl health <br>kubectl get nodes -o wide </pre><p>Setelah konfigurasi diterapkan, Talos beralih dari akses Maintenance Mode ( — insecure) ke Talos API terautentikasi menggunakan talosconfig. Bootstrap kemudian menginisialisasi etcd agar Kubernetes control plane dapat beroperasi. (<a href="https://docs.siderolabs.com/talos/v1.14/getting-started/getting-started">Talos — Getting Started</a>)</p><p>Keberhasilan fase pertama ditentukan oleh tiga indikator:</p><ol><li><strong>Kubernetes API tersedia</strong> dan dapat diakses melalui kubectl.</li><li><strong>etcd memiliki satu anggota aktif</strong>, yaitu CP01.</li><li><strong>CP01 berstatus Ready</strong> sebagai Kubernetes control-plane node.</li></ol><p>Ketiga indikator tersebut digunakan untuk memastikan bahwa control plane pertama telah terbentuk sebelum melanjutkan scaling ke CP02 dan CP03. (<a href="https://kubernetes.io/docs/reference/node/node-status/">Kubernetes — Node Status</a>)</p><blockquote>Bootstrap membentuk state awal cluster, sedangkan readiness menunjukkan bahwa node telah siap beroperasi dalam Kubernetes.</blockquote><p><strong>Fase Kedua — Menambahkan Dua Control Plane</strong></p><p>Setelah CP01 berstatus Ready, tahap berikutnya adalah melakukan <em>scale-up</em> dengan menambahkan CP02 dan CP03 secara bertahap.</p><p>Kedua node menggunakan <strong>identitas dan secrets cluster yang sama</strong> dengan CP01, tetapi memiliki hostname serta <em>machine configuration</em> masing-masing. Tidak diperlukan bootstrap ulang karena kedua control plane akan bergabung ke cluster yang sudah terbentuk. (<a href="https://docs.siderolabs.com/talos/v1.14/deploy-and-manage-workloads/scaling-up">Talos — Scaling Up</a>)</p><p><strong><em>Implementasi dan Verifikasi</em></strong></p><p>Proses penambahan control plane dilakukan secara berurutan, dimulai dari CP02:</p><pre># Tambahkan Control Plane 02 <br>talosctl apply-config --insecure \ <br>  -n &lt;CP2_IP&gt; -f _out/controlplane-cp2.yaml <br> <br># Verifikasi Kubernetes Node dan etcd <br>kubectl get nodes -o wide <br>talosctl etcd members <br><br>Setelah CP02 berhasil bergabung, proses yang sama dilanjutkan untuk CP03: <br><br># Tambahkan Control Plane 03 <br>talosctl apply-config --insecure \ <br>  -n &lt;CP3_IP&gt; -f _out/controlplane-cp3.yaml <br> <br># Verifikasi seluruh control plane <br>kubectl get nodes -o wide <br>talosctl etcd members </pre><p>Pada tahap ini, verifikasi dilakukan terhadap dua indikator utama:</p><ol><li><strong>Kubernetes Node Ready</strong> — CP01, CP02, dan CP03 terdaftar sebagai control-plane node dengan status Ready.</li><li><strong>etcd Membership</strong> — Ketiga control plane terdaftar sebagai anggota etcd dengan status <em>non-learner</em>.</li></ol><p>Hasil akhirnya menunjukkan tiga control plane telah berhasil bergabung ke Kubernetes cluster dan menjadi anggota voting etcd.</p><blockquote>Scaling control plane bukan membentuk cluster baru, melainkan memperluas cluster existing dengan tetap mempertahankan identitas dan konsistensi etcd.</blockquote><p><strong>Fase Ketiga — Menambahkan Dua Worker</strong></p><p>Setelah ketiga control plane berstatus Ready, tahap terakhir adalah menambahkan dua worker node (srvwrk1ab01 dan srvwrk1ab02) sebagai tempat menjalankan workload Kubernetes.</p><p>Berbeda dengan control plane, worker tidak berpartisipasi dalam etcd. Worker menjalankan komponen seperti <strong>kubelet dan container runtime</strong> untuk mengelola Pod dan container yang dijadwalkan oleh Kubernetes. Proses penambahan dilakukan dengan menerapkan <em>machine configuration</em> sesuai role worker, tanpa bootstrap ulang. (<a href="https://docs.siderolabs.com/talos/v1.14/deploy-and-manage-workloads/scaling-up">Talos — Scaling Up</a>)</p><p><strong><em>Implementasi dan Verifikasi</em></strong></p><p>Kedua worker ditambahkan secara bertahap menggunakan konfigurasi masing-masing:</p><pre># Tambahkan Worker 01 <br>talosctl apply-config --insecure \ <br>  -n &lt;W1_IP&gt; -f _out/worker.yaml <br> <br># Tambahkan Worker 02 <br>talosctl apply-config --insecure \ <br>  -n &lt;W2_IP&gt; -f _out/worker-w2.yaml <br> <br># Verifikasi seluruh Kubernetes Node <br>kubectl get nodes -o wide </pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-MP30coiQGV0tBQlocu2gQ.png" /><figcaption>Gambar 6. Talosctl get members</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VIEmYAW2BW9Z-oFjA_s9aw.png" /><figcaption>Gambar 7. Kubectl get nodes</figcaption></figure><p>Setelah konfigurasi diterapkan, kubelet melakukan proses registrasi ke Kubernetes API Server. Node kemudian mencapai status Ready setelah persyaratan kesiapan, termasuk kondisi jaringan dan layanan yang diperlukan, terpenuhi. Proses ini dapat membutuhkan waktu sehingga node tidak selalu langsung muncul dalam daftar Kubernetes. (<a href="https://kubernetes.io/docs/concepts/architecture/nodes/">Kubernetes — Nodes</a>)</p><p>Keberhasilan fase ketiga ditentukan oleh dua indikator:</p><ol><li><strong>Worker Node Ready</strong> — Kedua worker berhasil terdaftar dengan status Ready.</li><li><strong>Cluster Membership</strong> — Kubernetes menampilkan lima node aktif, terdiri dari tiga control plane dan dua worker.</li></ol><h4>Memahami etcd Quorum dan Control Plane Scaling</h4><p>Salah satu konsep terpenting dalam arsitektur Kubernetes HA adalah etcd quorum. etcd menggunakan algoritma konsensus Raft untuk mengoordinasikan state di antara anggota cluster. Agar dapat mengambil keputusan yang membutuhkan konsensus, sebuah cluster etcd perlu memiliki mayoritas anggota voting yang tersedia.</p><p>Jumlah mayoritas tersebut dikenal sebagai quorum, dan dihitung dengan floor(N/2) + 1.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gDUIf1-yBhkd_cj8vBoG6Q.png" /><figcaption>Gambar 8. Quorum ETCD.</figcaption></figure><p>Pada awal eksperimen, CP01 merupakan satu-satunya anggota etcd.</p><p>Saat CP02 berhasil bergabung sebagai voting member kedua, jumlah anggota bertambah menjadi dua. Tetapi cluster belum memiliki toleransi kegagalan satu node karena kedua anggota masih dibutuhkan untuk mencapai quorum.</p><p>Baru setelah CP03 menjadi anggota voting ketiga, cluster dapat mempertahankan mayoritas ketika satu anggota tidak tersedia.</p><p>Inilah alasan penambahan control plane tidak boleh hanya dilihat sebagai peningkatan jumlah server. Penambahan tersebut mengubah karakteristik konsensus dan toleransi kegagalan cluster.</p><p>Dua baris genap pada tabel, yaitu 2 dan 4 anggota, adalah yang paling sering disalahpahami. Dua anggota lebih rapuh daripada satu dalam satu hal: ada dua mesin yang harus hidup, tetapi toleransinya tetap nol. Empat anggota juga tidak lebih baik daripada tiga, karena toleransinya sama sementara ada satu mesin tambahan yang bisa gagal. Itu alasan control plane dibangun dalam jumlah ganjil (<a href="https://etcd.io/docs/v3.6/faq/">etcd: FAQ</a>).</p><p>Bila quorum hilang, etcd berhenti menerima penulisan. kube-apiserver tidak bisa menyimpan perubahan apa pun: membuat Pod, melakukan scale, atau memperbarui Deployment. Pod yang sudah berjalan di worker biasanya tetap berjalan karena kubelet mengelolanya secara lokal, tetapi cluster tidak bisa beradaptasi sampai quorum pulih. Inilah mengapa “API tidak tersedia” dan “aplikasi mati” adalah dua peristiwa yang berbeda.</p><p>Setelah setiap perubahan keanggotaan, tiga perintah ini yang saya jalankan:</p><pre>talosctl -n &lt;CP_IP&gt; etcd members   # siapa saja anggotanya, dan apakah masih learner <br>talosctl -n &lt;CP_IP&gt; etcd status    # leader, ukuran database, raft index tiap anggota <br>talosctl -n &lt;CP_IP&gt; service etcd   # status layanan etcd pada node itu </pre><p>Ada dua faktor yang tidak terlihat dari tabel tetapi ikut menentukan. Pertama, etcd sensitif terhadap latensi disk dan jaringan antar anggota: lonjakan latensi bisa memicu pemilihan leader ulang. Kedua, bila ketiga VM control plane ternyata berada di host fisik yang sama, tiga anggota itu secara praktis menjadi satu titik kegagalan. Apakah platform menyediakan anti-affinity untuk VM adalah pertanyaan yang layak diajukan ke penyedia cloud sebelum mengklaim HA.</p><p>Quorum menjelaskan konsistensi state control plane. Ia tidak menjamin akses API, jaringan, atau aplikasi akan selalu tersedia, dan itulah yang dibahas di bagian berikutnya.</p><h4>Virtual IP: Memisahkan API Availability dari Node Availability</h4><p>Memiliki tiga control plane tidak otomatis menjamin Kubernetes API selalu tersedia. Jika endpoint API hanya mengarah ke CP01, kegagalan node tersebut dapat memutus akses meskipun CP02 dan CP03 masih sehat.</p><p>Untuk mengatasi ketergantungan tersebut, lab ini menggunakan <strong>Virtual IP (VIP)</strong> sebagai endpoint bersama Kubernetes API.</p><p><strong>Bagaimana Virtual IP Bekerja?</strong></p><p>Talos menggunakan mekanisme pemilihan berbasis etcd untuk menentukan control plane yang memegang VIP. Ketika pemegang VIP tidak tersedia, alamat virtual dapat berpindah ke control plane lain sehingga endpoint Kubernetes tetap sama. Mekanisme ini membutuhkan jaringan Layer 2 yang mendukung perpindahan alamat IP. (<a href="https://docs.siderolabs.com/talos/v1.14/networking/advanced/vip">Talos — Virtual IP</a>)</p><p>Ada dua prinsip penting:</p><ul><li><strong>VIP bergantung pada etcd</strong>, sehingga tidak digunakan sebagai endpoint untuk bootstrap awal cluster.</li><li><strong>Pisahkan endpoint administrasi:</strong> kubectl menggunakan VIP pada port 6443, sedangkan talosctl menggunakan IP control plane pada port 50000.</li></ul><p><strong><em>Konfigurasi VIP pada Talos</em></strong></p><p>VIP dikonfigurasi pada setiap control plane melalui machine configuration:</p><pre>machine: <br>  network: <br>    interfaces: <br>      - interface: eth0 <br>        vip: <br>          ip: &lt;VIP&gt; <br>cluster: <br>  apiServer: <br>    certSANs: <br>      - &lt;VIP&gt; </pre><p>VIP menyediakan satu alamat Kubernetes API melalui satu control plane aktif. Sementara itu, <strong>TCP Load Balancer</strong> dapat meneruskan koneksi ke beberapa kube-apiserver berdasarkan health check.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vgCrOglup0j3cTId3M-DiA.png" /><figcaption>Tabel 1. Perbandingan VIP vs LoadBalancer</figcaption></figure><p>Untuk kebutuhan production-grade, Load Balancer menjadi salah satu pendekatan yang dapat dipertimbangkan karena menyediakan health check dan pemilihan backend. Namun, layanan Load Balancer itu sendiri juga harus memiliki redundansi agar tidak menjadi <em>single point of failure</em>. (<a href="https://docs.siderolabs.com/talos/v1.14/getting-started/prodnotes">Talos — Production Notes</a>)</p><p><strong>Talos API dan Kubernetes API</strong></p><p>Dalam mengoperasikan Kubernetes berbasis Talos Linux, penting untuk memahami bahwa <strong>talosctl dan kubectl berkomunikasi melalui dua API yang berbeda</strong>.</p><p>talosctl digunakan untuk mengelola sistem operasi dan layanan pada node, sedangkan kubectl digunakan untuk mengelola resource Kubernetes. Keduanya memiliki endpoint, port, dan kredensial tersendiri.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DtgQyKGJNEENEUtpSv4Rpw.png" /><figcaption>Tabel 2. Perbandingan Talos API vs Kubernetes API</figcaption></figure><p>Perbedaan ini penting ketika melakukan troubleshooting. <strong>Talos API yang sehat tidak selalu berarti Kubernetes API tersedia</strong>, begitu pula sebaliknya.</p><p>Sebagai contoh, talosctl dapat terhubung ke node meskipun Kubernetes API belum berjalan akibat masalah pada etcd atau kube-apiserver. Hal tersebut memungkinkan pemeriksaan kondisi sistem operasi tanpa bergantung pada ketersediaan Kubernetes API.</p><pre># Memeriksa Talos API (TCP 50000) <br>talosctl --nodes &lt;CP_IP&gt; version <br>talosctl --nodes &lt;CP_IP&gt; service etcd <br> <br># Memeriksa Kubernetes API (TCP 6443) <br>kubectl get nodes -o wide <br>kubectl get --raw=/readyz </pre><p>Selain melalui CLI, <strong>dashboard Talos</strong> menyediakan informasi mengenai stage mesin, status service, dan komponen control plane. Sementara itu, Kubernetes menggunakan kondisi Ready untuk menunjukkan kesiapan node dalam menjalankan workload. (<a href="https://kubernetes.io/docs/reference/node/node-status/">Kubernetes — Node Status</a>)</p><p><strong>Lessons Learned: Prinsip Operasional dari Talos untuk Kubernetes</strong></p><p>Membangun Kubernetes secara bertahap memberikan beberapa pelajaran penting, terutama dalam menjaga konsistensi konfigurasi, identitas cluster, dan proses operasional.</p><p>Berikut lima prinsip utama yang perlu diperhatikan:</p><ol><li><strong>Bootstrap hanya sekali.</strong> Proses talosctl bootstrap digunakan untuk menginisialisasi cluster etcd pertama kali. Control plane dan worker berikutnya bergabung ke cluster yang sudah terbentuk tanpa melakukan bootstrap ulang.</li><li><strong>Pertahankan satu identitas cluster.</strong> Seluruh node harus menggunakan secrets dan Certificate Authority (CA) yang konsisten. secrets.yaml dibuat sekali dan disimpan secara aman untuk kebutuhan scaling maupun recovery.</li><li><strong>Validasi konfigurasi sebelum diterapkan.</strong> Machine configuration yang dihasilkan dari template atau patch perlu diperiksa sebelum apply-config, terutama hostname, endpoint, dan konfigurasi spesifik node.</li><li><strong>Verifikasi setiap penambahan node.</strong> Pastikan layanan Talos berjalan, keanggotaan etcd sesuai untuk control plane, dan Kubernetes Node berstatus Ready sebelum melanjutkan scaling.</li><li><strong>Pisahkan pengelolaan Talos dan Kubernetes.</strong> talosctl menggunakan Talos API dan talosconfig, sedangkan kubectl menggunakan Kubernetes API dan kubeconfig. Keduanya harus diperiksa secara terpisah ketika troubleshooting.</li></ol><blockquote>Konsistensi konfigurasi dan verifikasi bertahap merupakan fondasi utama dalam mengoperasikan Kubernetes cluster yang reliable.</blockquote><p><strong>High Availability Harus Diuji, Bukan Hanya Dikonfigurasi</strong></p><p>Memiliki tiga control plane, dua worker, dan seluruh node berstatus Ready adalah fondasi yang baik. Namun, <strong>High Availability (HA) tidak ditentukan oleh jumlah node saja, melainkan oleh ketahanan tiap lapisan infrastruktur terhadap kegagalan.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PipIeykWGOzNeWxZzt1G_g.png" /><figcaption>Gambar 9. Layering Kubernetes.</figcaption></figure><p>Setiap lapisan memiliki mekanisme gagal dan pemulihannya sendiri. Tiga anggota etcd dapat menjaga quorum ketika satu anggota gagal, tetapi itu belum otomatis menjamin Kubernetes API atau aplikasi tetap tersedia. VIP atau Load Balancer membantu menjaga akses API, tetapi tidak menggantikan kebutuhan redundansi workload. (<a href="https://kubernetes.io/docs/concepts/architecture/">Kubernetes — Cluster Architecture</a>)</p><p>Karena itu, HA harus divalidasi melalui pengujian kegagalan yang terkontrol, seperti kehilangan satu control plane, failover endpoint API, kegagalan worker, dan pemulihan data.</p><p><strong>High Availability bukan sekadar menghilangkan Single Point of Failure pada satu komponen, tetapi memastikan kegagalan pada satu lapisan tidak menghentikan seluruh layanan.</strong></p><p>Pada akhirnya, lima node Ready membuktikan bahwa cluster berhasil dibangun, sedangkan kemampuan bertahan dan pulih dari kegagalan adalah ukuran reliability yang sebenarnya.</p><p><strong>Referensi</strong></p><ul><li><a href="https://medium.com/@rendinicolasm/mengelola-server-lewat-api-mengenal-talos-linux-untuk-infrastruktur-kubernetes-90f2da9f91e4">Artikel Part 1: Mengelola Server Lewat API</a></li><li><a href="https://github.com/mahendrarendi/talos-lab/releases/tag/v0.1.0">Repository talos-lab</a></li><li><a href="https://docs.siderolabs.com/talos/v1.14/learn-more/control-plane">Talos: Control Plane</a></li><li><a href="https://docs.siderolabs.com/talos/v1.14/configure-your-talos-cluster/system-configuration/reproducible-machine-configuration">Talos: Reproducible Machine Configuration</a></li><li><a href="https://docs.siderolabs.com/talos/v1.14/deploy-and-manage-workloads/scaling-up">Talos: Scaling Up</a></li><li><a href="https://docs.siderolabs.com/talos/v1.12/networking/advanced/vip">Talos: Virtual (shared) IP</a></li><li><a href="https://docs.siderolabs.com/talos/v1.14/getting-started/prodnotes">Talos: Production Notes</a></li><li><a href="https://talos.dev/v1.7/advanced/disaster-recovery">Talos: Disaster Recovery</a></li><li><a href="https://kubernetes.io/docs/concepts/overview/components/">Kubernetes: Components</a></li><li><a href="https://kubernetes.io/docs/concepts/architecture/">Kubernetes: Cluster Architecture</a></li><li><a href="https://kubernetes.io/docs/reference/node/node-status/">Kubernetes: Node Status</a></li><li><a href="https://kubernetes.io/docs/reference/using-api/health-checks/">Kubernetes: API Health Checks</a></li><li><a href="https://etcd.io/docs/v3.6/faq/">etcd: FAQ</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff8d5f7a6814" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mengelola Server Lewat API: Mengenal Talos Linux untuk Infrastruktur Kubernetes]]></title>
            <link>https://medium.com/@rendinicolasm/mengelola-server-lewat-api-mengenal-talos-linux-untuk-infrastruktur-kubernetes-90f2da9f91e4?source=rss-f5e3249994ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/90f2da9f91e4</guid>
            <dc:creator><![CDATA[mahendrarendi]]></dc:creator>
            <pubDate>Sun, 11 Oct 2026 01:51:47 GMT</pubDate>
            <atom:updated>2026-10-11T02:11:22.252Z</atom:updated>
            <content:encoded><![CDATA[<h4>Hands-on Talos Linux v1.14.1 di DekaFlexy Cloudeka (FX2): dari custom image hingga Maintenance Mode, sambil memahami pendekatan immutable dan API-driven untuk node Kubernetes.</h4><p>Ketika sebuah server Linux bermasalah, apa yang anda lakukan pertama kali? Bagi kebanyakan SysAdmin, DevOps, dan Cloud Engineer, jawabannya hampir sama: membuka SSH. Dari sana kita memeriksa proses, membaca log, hingga mengubah konfigurasi server. Saya pun memulai eksplorasi Talos Linux dengan kebiasaan yang sama.</p><p>Namun, Talos menawarkan pendekatan yang berbeda. Alih-alih menjadikan akses shell sebagai pusat administrasi, Talos menempatkan API dan konfigurasi deklaratif sebagai antarmuka utama. Dalam lab ini, saya mencoba memahami perbedaan tersebut sejak mesin pertama kali boot, hingga node dapat dijangkau dan diperiksa dari management host, sebelum Kubernetes sendiri di-bootstrap.</p><h4>Mulai Mengeksplorasi Talos Linux</h4><p>Motivasi saya bukan sekadar mencoba distro Linux baru. Saya ingin memahami konsekuensi operasional ketika sistem operasi dirancang khusus untuk satu workload: Kubernetes.</p><p>Di Linux general-purpose, seperti Ubuntu, Debian, CentOS, Red Hat Enterprise Linux (RHEL) dan lainya, fleksibilitas memasang paket dan mengubah server secara langsung sering terasa membantu. Namun, perubahan manual semacam itu berpotensi membuat dua atau lebih server yang seharusnya identik justru memiliki state berbeda. Pola ini akrab bagi siapapun yang pernah berhadapan dengan configuration drift.</p><p>Dari situ muncul pertanyaan yang ingin saya jawab: bagaimana jika konfigurasi pada node / mechine tidak lagi bergantung pada serangkaian pekerjaan manual setelah SSH, melainkan didefinisikan sebelum node mula menjalankan perannya? Talos menyediakan lingkungan yang menarik untuk bereksperimen dengan gagasan ini, walaupun pendekatanya menuntut kedisiplinan pada konfigurasi, jaringan dan kredensial API.</p><p>Saya juga sengaja memisahkan belajar Talos Linux dari membangun Kubernetes HA. Pada bagian pertama ini, kita akan belajar: apakah Talos dapat boot?, apakah ia memiliki identitas jaringan yang jelas?, dan apakah ia dapat diobervasi dari luar secara aman?</p><h4>Mengenal Talos Linux dan Filosofinya</h4><p>Talos Linux adalah sistem operasi minimal yang ditujukan khusus untuk menjalankan Kubernetes (<a href="https://www.talos.dev/">Talos Linux, What is Talos</a>). Dokumentasi dari Sidero Labs menekankan empat karakter utamanya:</p><ul><li>Dikelola lewat API.</li><li>Filesystem yang immutable.</li><li>Package yang minimal.</li><li>Pendekatan secure-by-default (<a href="https://www.talos.dev/">Talos Linux</a>).</li></ul><p>Dan ini bukan clickbait bahwa Talos Linux kebal terhadap masalah keamanan, melainkan pilihan desain yang mengurangi antarmuka adminsitrasi dan komponen Sistem Operasi (OS) yang perlu dikelola.</p><p>Bagi saya, konsep <em>immutable</em> paling tepat dipahami sebagai perubahan paradigma dalam pengelolaan <em>lifecycle</em> sistem operasi. Dalam pendekatan ini, sistem operasi tidak lagi diperlakukan sebagai mesin yang dapat dimodifikasi secara <em>ad-hoc</em> (perubahan yang dilakukan secara spontan atau berdasarkan kebutuhan sesaat, tanpa melalui proses yang terencana dan terstandarisasi), melainkan sebagai sistem yang dikelola secara konsisten, terkontrol, dan deklaratif.</p><p>Pada Talos Linux, pendekatan ini diwujudkan melalui pengelolaan konfigurasi secara deklaratif, penggunaan Talos API untuk melakukan inspeksi dan operasi node, serta mekanisme pembaruan sistem operasi berbasis <em>image</em>. Dengan demikian, pengelolaan sistem tidak lagi bergantung pada instalasi atau pembaruan paket secara individual seperti yang umum dilakukan pada server Linux <em>general-purpose</em>.</p><p>Pendekatan <em>API-driven</em> pada Talos Linux juga memberikan pemisahan tanggung jawab yang lebih jelas antara lapisan sistem operasi dan Kubernetes. Talos API digunakan untuk mengelola sistem operasi, melakukan inspeksi kondisi node, serta menjalankan operasi administratif seperti konfigurasi, <em>reboot</em>, dan <em>upgrade</em>. Sementara itu, Kubernetes API berperan dalam pengelolaan sumber daya cluster, seperti Pod, Deployment, Service, dan objek Kubernetes lainnya.</p><p>Pemisahan ini penting untuk dipahami karena node yang sudah dapat diakses melalui Talos API belum tentu memiliki Kubernetes API yang berfungsi dengan normal. Dengan kata lain, keberhasilan komunikasi dengan Talos API tidak secara otomatis menandakan bahwa Kubernetes cluster sudah siap digunakan. Perbedaan kedua lapisan ini menjadi salah satu aspek penting yang akan kembali dibahas dalam tahapan eksperimen berikutnya (<a href="https://docs.siderolabs.com/talos/v1.14/">Dokumentasi Talos v1.14</a>).</p><h4>Talos Linux vs Linux Server Tradisional</h4><p>Perbedaan terbesarnya ada pada cara kita berinteraksi dengan server. Tabel berikut akan merangkumnya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RvrbUzKpmn-3NCGFEOx0aA.png" /><figcaption>Tabel 1. Perbedaan Talos dan General Linux Distro</figcaption></figure><p>Perbandingan ini tidak berarti Linux tradisional buruk, Ubuntu dan RHEL memberi fleksibilitas yang sangat berharga untuk banyak kebutuhan. Talos Linux memilih membatasi fleksibilitas itu demi konsistensi dalam mengelola node Kubernetes. Trade-off ini perlu dipahami sejak awal agar ekspektasi kita tepat: ketika tidak ada ssh, solusinya bukan mencari cara mengaktifkan SSH, melainkan belajar API dan workflow yang tersedia.</p><p>Dari sudut pandang engineering, perubahan paling penting adalah mengganti pertanyaan “perintah apa yang harus saya jalankan pada server?” menjadi “state seperti apa yang seharusnya dimiliki node, dan melalui konfigurasi apa state itu didefinisikan” (<a href="https://docs.siderolabs.com/talos/v1.14/">Talos for Linux Admins</a>).</p><h4>Membangun Lab di Dekaflexy Cloudeka (FX2)</h4><p>Lab ini berjalan di layanan <a href="https://www.cloudeka.id/en/products/deka-flexi-en/">Dekaflexy Cloudeka (FX2)</a>, layanan public cloud berbasis IaaS milik Lintasarta Cloudeka dengan model pay-per-use, yang di bangun di atas teknologi Red Hat. Platform ini dikelola langsung oleh Lintasarta dan data center-nya berada di Indonesia, sehingga relevan bagi organisasi yang memperhatikan kedaulatan data (data sovereignty). Berbeda dari hyperscaler global, alur provisioning-nya, mulai dari impor image sampai pengaturan jaringan VM, mengikuti mekanisme platform Lintasarta Cloudeka.</p><p>Lab ini terdiri dari dua peran:</p><ul><li>srvcntrl1ab01 sebagai controller atau jumphost yang berfungsi untuk mangemen host tempat talosctl .</li><li>srvcp1ab01 sebagai VM Talos Linux.</li></ul><p>Pada tahap berikutnya , lab ini berkembang menjadi 3 Control Plane, dan 2 Worker.</p><p>Satu hal perlu disadari sejak awal: perilaku instalasi Talos berbeda di setiap platform, tetapi secara konsep tetap sama. Pada bare metal, Talos di-boot lewat ISO atau PXE, dan ketika di-boot dari ISO ia belum menginstal dirinya ke disk sampai machine configuration diterapkan. Di VMware ada panduan tersendiri untuk membuat VM Talos, sedangkan di platform cloud, provisioning mengikuti mekanisme provider masing-masing. Di semua platform polanya serupa: Talos di-boot, menerima machine configuration , lalu dikelola lewat API. Yang berbeda hanyalah penyesuaian teknis, seperti format image, cara boot, dan cara menyiapkan jaringan awal, yang mengikuti platform dan teknologi yang dipakai. Karena itu, panduan instalasi dari satu platform tidak bisa disalin begitu saja ke platform lain, dan pilihan image serta metode provisioning menjadi keputusan penting (<a href="https://docs.siderolabs.com/talos/v1.14/platform-specific-installations/bare-metal-platforms/iso">Dokumentasi Talos: Bare Metal ISO</a>).</p><p>Saya memilih metode Import Custom Image dari Cloudeka. Metode ini berbeda dari pola mengunggah ISO lalu memasangnya secara manual lewar CD-ROM: image yang dipilih harus cocok dengan mekanisme import dan boot platform cloud. saya mengunduh image Talos v1.14.1 dengan arsitektur amd64 dari Talos Image Factory dalam format QCOW2, format disk image virtual dari QEMU yang banyak dipakai di lingkungan KVM. Image tersebut saya impor sebagai Custom Image di Cloudeka, lalu dipakai untuk membuat VM Talos. Saya juga menghindari extension yang tidak diperlukan untuk instalasi pertama.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lLNR-NWaOEakMSXeakzizA.png" /><figcaption>Gambar 1. Cloudeka Dasboard Custom Image.</figcaption></figure><p>Talos Image Factory menyediakan beberapa jenis boot asset dan opsi system extension. Pelajaran saya: extension bukan daftar paket yag harus dichecklist sebanyak mungkin waktu instalasi. Pilih hanya bila ada kebutuhan perangkat keras atau integrasi hypervisor yang jelas. Begitu pula dengan format <em>image</em>, seperti QCOW2, RAW, dan ISO, yang memiliki karakteristik dan kegunaan berbeda sehingga tidak dapat dipertukarkan hanya dengan mengubah nama atau ekstensi file (<a href="https://factory.talos.dev/">Talos Image Factory</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kt0mLwkIt6idyFVu-fP6ng.png" /><figcaption>Gambar 2. Talos Image Factory</figcaption></figure><h4>Dari Custom Image hingga Maintenance Mode</h4><p>Setelah custom image dipakai untuk menyalakan VM, saya membuka console jarak jauh menggunakan VNC untuk melihat Talos masuk ke Maintenance Mode. Tampilanya terasa asing: tidak ada promt login Linux seperti biasa. Namun, justru disitulah titik pentingnya. OS sudah boot dan menyediakan jalur untuk menerima konfigurasi awal, sementara identitas dan peran Kubernetes belum di terapkan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vnn5jjAXGqfOpdwWDeHdaQ.png" /><figcaption>Gambar 3. Talos Dashboard</figcaption></figure><p>Saya kemudian mengatur hostname dan jaringan lewat console. Pada hasil akhir experiment yang tercatat, node memakai hostname srvcp1ab01, alamat 10.87.44.20/24, gateway 10.87.44.1, serta DNS resolver 202.152.0.2 dan 202.152.5.36. Nilai-nilai ini adalah fakta spesifik dari lab ini, bukan rekomendasi alamat untuk lingkungan lain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z9rfIZc6m9UW1eNO7OnoGw.png" /><figcaption>Gambar 4. Talos Network Config</figcaption></figure><p>Hostname nantinya menjadi salah satu dasar identitas node ketika kubelet mendaftarkan diri ke Kubernetes. Namun, penting membedakan dua tahap: hostname yang sudah tampil di layar Talos tidak berarti node tersebut sudah tercatat di cluster Kubernetes.</p><p>Ada satu detail yang mudah menjebak: tulisan “Ready: True” di Maintenance Mode tidak sama dengan “Node Ready” di Kubernetes. Setiap lapisan punya indikator dengan konteksnya sendiri (<a href="https://docs.siderolabs.com/talos/v1.14/">Dokumentasi Talos v1.14</a>). Saya baru akan menyebut node Kubernetes siap ketika informasi dari Kubernetes sendiri mendukung klaim itu, dan itu menjadi materi artikel kedua.</p><h4>Mengelola Talos melalui API</h4><p>Setelah jaringan VM dapat dijangkau, saya berpindah ke srvcntrl1ab01. Di sinilah gagasan Talos sebagai OS yang digerakkan API terasa konkret: saya tidak memerlukan SSH ke “srvcp1ab01” untuk menanyakan versi sistem atau disk yang terdeteksi. Cukup menggunakan perintahtalosctl.</p><p>Versi talosctl harus disesuaikan dengan versi Talos yang berjalan. Catatan eksperimen saya memakai v1.14.1. Untuk artikel ini saya memakai versi yang konsisten, supaya pembaca tidak meniru kombinasi client lama dan server baru.</p><pre>VERSION=v1.14.1<br>curl -fLo talosctl &quot;https://github.com/siderolabs/talos/releases/download/${VERSION}/talosctl-linux-amd64&quot;<br>chmod +x talosctl<br>sudo install -m 0755 talosctl /usr/local/bin/talosctl<br>talosctl version --client</pre><p>Karena node masih berada di Maintenance Mode, koneksi awal diuji dengan flag --insecure. Mode ini khusus untuk tahap provisioning awal. Untuk administrasi normal setelah machine configuration diterapkan, Talos memakai kredensial dan koneksi terautentikasi.</p><pre>root@cntrl1ab01:~# talosctl version --insecure --nodes 10.87.44.20<br>Client:<br>    Tag:         v1.14.1<br>    SHA:         2f86b9d2<br>    Built:<br>    Go version:  go1.26.8<br>    OS/Arch:     linux/amd64<br>Server:<br>    NODE:        10.87.44.20<br>    Tag:         v1.14.1<br>    SHA:         2f86b9d2<br>    Built:<br>    Go version:  go1.26.8<br>    OS/Arch:     linux/amd64<br>    Enabled:     RBAC<br><br>root@cntrl1ab01:~# talosctl get disks --insecure --nodes 10.87.44.20<br>NODE          NAMESPACE   TYPE   ID      VERSION   SIZE     READ ONLY   TRANSPORT   ROTATIONAL   WWID   MODEL<br>10.87.44.20   runtime     Disk   sda     1         50 GB   false       virtio      false       -      Virtual Disk</pre><p>Pada hasil lab, client dan server sama-sama melaporkan v1.14.1. Pemeriksaan disk mendeteksi dua loop device read-only serta /dev/vda berkapasitas sekitar 50 GB yang writable dan menggunakan transport VirtIO. Pemeriksaan ini penting sebelum menentukan target instalasi, karena tidak semua device yang muncul adalah disk tujuan yang boleh ditimpa.</p><p>Di tahap ini saya juga memeriksa resolusi k8s-lab.internal pada management host. Nama itu adalah nama lokal lab. Resolusi yang berhasil di satu mesin tidak otomatis berarti nama yang sama dapat di-resolve dari semua node Talos, sehingga DNS perlu diperlakukan sebagai desain jaringan tersendiri (<a href="https://docs.siderolabs.com/talos/v1.14/">Talos CLI dan machine configuration</a>).</p><h4>Lessons Learned dan What’s Next</h4><p>Tiga pelajara paling berharga dari perjalanan provisioning ini:</p><ul><li>Pahami batas setiap indikator: Maintenance Mode membuktikan Talos siap menerima konfigurasi. Koneksi talosctl membuktikan API sistem operasi dapat diakses. Pemeriksaan disk membantu memastikan perangkat yang tersedia di dalam sistem operasi.</li><li>Jaga konsistensi konfigurasi: Versi talosctl harus selaras dengan versi Talos, dan nama atau alamat IP yang di pakai harus dapat di-reseolve dari seteiap tempat yang membutuhkannya.</li><li>Jangan terburu-buru menyimpulkan Kubernetes sudah siap: Tidak satupu bukti diatasa otomatis menunjukan bahwa etcd atau controlplane Kubernetes sudah berjalan.</li></ul><p>Satu masalah yang pernah saya temui juga relevan disini. Setelah VM baru memakai IP berbeda, talosctl sempat tetap mengarah ke alamat node sebelumnya, sehingga gagal tersambung. Penyebabnya ada pada state konfiurasi client administrasi, bukan semata-mata pada OS Talos. Sejak saat itu saya membiasakan diri memeriksa konteks dan endpoint sebelum mendiagnosis kegagalan pada node maupun cluster.</p><blockquote>Bagi saya, esensi Talos bukan sekadar “Linux tanpa SSH”. Ia mengubah cara kita memandang node: bukan lagi server yang selalu perlu disentuh secara manual, melainkan komponen infrastruktur yang perilaku dan state-nya dapat didefinisikan, diamati, dan direproduksi.</blockquote><h4>Referensi</h4><ul><li><a href="https://www.talos.dev/">Talos Linux project</a></li><li><a href="https://docs.siderolabs.com/talos/v1.14/">Dokumentasi Talos v1.14</a></li><li><a href="https://docs.siderolabs.com/talos/v1.14/platform-specific-installations/bare-metal-platforms/iso">Dokumentasi Talos: Bare Metal ISO</a></li><li><a href="https://factory.talos.dev/">Talos Image Factory</a></li><li><a href="https://www.cloudeka.id/en/products/deka-flexi-en/">Cloudeka Deka Flexi (FX2)</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=90f2da9f91e4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mental Model untuk Memahami Arsitektur Data Center AI & HPC]]></title>
            <link>https://medium.com/@rendinicolasm/mental-model-untuk-memahami-arsitektur-data-center-ai-hpc-9e332a4d6d43?source=rss-f5e3249994ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e332a4d6d43</guid>
            <category><![CDATA[hpc]]></category>
            <category><![CDATA[nvidia-gpu]]></category>
            <category><![CDATA[data-center]]></category>
            <category><![CDATA[ai-infrastructure]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[mahendrarendi]]></dc:creator>
            <pubDate>Sun, 04 Oct 2026 13:18:00 GMT</pubDate>
            <atom:updated>2026-10-05T03:19:04.943Z</atom:updated>
            <content:encoded><![CDATA[<h4>Memahami GPU Node, Networking, Storage, dan Scale-out Architecture</h4><p>Setiap kali kita membuka aplikasi bank, mengirim email, atau berbelanja online, selalu ada infrastruktur IT yang bekerja di belakangnya: server yang menjalankan aplikasi, storage yang menyimpan data, dan jaringan yang menghubungkan komponen-komponen tersebut.</p><p>Pola seperti ini sudah kita kenal selama puluhan tahun. Pada banyak aplikasi tradisional, sistem harus menangani banyak permintaan kecil yang datang secara bersamaan. Misalnya, ribuan pengguna mengecek saldo pada detik yang sama. Setiap request relatif ringan, berdiri sendiri, dan umumnya dapat diproses oleh server yang berbeda.</p><p>Karena itu, infrastruktur IT tradisional banyak dirancang untuk melayani banyak pekerjaan kecil yang berbeda-beda secara paralel.</p><p><strong>Infrastruktur AI memiliki karakteristik yang berbeda.</strong></p><p>Melatih sebuah model AI bukan sekadar menjalankan ribuan request kecil yang independen, tetapi lebih mirip <strong>satu pekerjaan komputasi yang sangat besar.</strong> Model harus memproses data dalam jumlah besar dan melakukan operasi matematika yang sama berulang kali untuk memperbarui miliaran, bahkan triliunan parameter.</p><p><strong>Di sinilah GPU menjadi komponen penting dalam Infrastruktur AI.</strong></p><p>Berbeda dengan CPU yang dirancang untuk menangani beragam jenis instruksi secara fleksibel. GPU memiliki banyak processing unit yang mampu menjalankan operasi matematika secara paralel. Karakteristik inilah yang membuat GPU jauh lebih cocok untuk workload AI seperti matrix dan tensor computation.</p><p>Namun satu GPU sering kali tidak cukup.</p><p>Ketika sebuah workload menggunakan banyak GPU, bahkan banyak server, masing-masing GPU tidak dapat bekerja sepenuhnya sendiri. Mereka harus saling bertukar hasil perhitungan, membaca dataset dari storage, dan menulis checkpoint secara terus-menerus.</p><p>Pada titik ini, network dan storage tidak lagi sekadar menjadi komponen pendukung. Keduanya ikut menentukan seberapa efektif seluruh komponen dapat bekerja sebagai satu sistem.</p><p>Dan justru di sinilah proses mempelajari AI infrastructure mulai terasa kompleks.</p><p>Sayangnya, ketika pertama kali mempelajari infrastruktur AI dan High Performance Computing (HPC), kita sering disuguhkan berbagai istilah dan nama produk yang sebelumnya jarang kita dengar:</p><p><em>H100. H200. HGX. DGX. NVLink. NVSwitch. ConnectX. BlueField. InfiniBand. Ethernet. RoCE. GPUDirect RDMA. Lustre.Etc.</em></p><p>Masalahnya istilah-istilah tersebut muncul secara bersamaan, padahal masing-masing punya fungsi dan tujuan yang berbeda di dalam arsitektur.</p><p>Ada yang berhubungan dengan <strong>compute</strong>, ada yang digunakan untuk komunikasi antar-GPU, ada yang menjadi bagian dari <strong>networking</strong>, dan ada juga yang berkaitan dengan <strong>storage</strong>. Ketika konteks tersebut belum kita pahami, semuanya terlihat seperti satu kumpulan teknologi yang rumit untuk dipahami.</p><p>Biasanya pertanyaan pertama justru bukan tentang produk tertentu, melainkan tentang gambaran besarnya:</p><ul><li>Sebenernya apa saja komponen yang membentuk sebuah AI/HPC Data Center?</li><li>Bagaimana compute, network, dan storage bisa saling berkomunikasi satu sama lain di dalam satu workload?</li></ul><p>Setelah gambaran besarnya mulai terlihat, pertanyaannya kemudian berkembang menjadi lebih teknis:</p><ul><li>Bagaimana GPU dalam satu server saling berkomunikasi?</li><li>Bagaimana GPU di server yang berbeda saling bertukar data?</li><li>Apa peran network adapter dalam komunikasi antar-server GPU?</li><li>Apakah setiap GPU membutuhkan network adapter sendiri untuk bisa berkomunikasi dengan server GPU yang lain?</li><li>Apakah komunikasi antar-GPU membutuhkan fabric khusus?</li><li>Bagaimana compute membaca dan menulis data ke storage?</li><li>Apakah storage harus menggunakan network khusus berperforma tinggi?</li><li>Apakah traffic compute, storage, management, dan user harus dipisahkan?</li></ul><p>Pertanyaan-pertanyaan seperti ini sangat wajar. Yang sering membuatnya terasa rumit bukan teknologinya, tetapi karena kita mencoba memahami istilah dan produk sebelum memahami fungsi serta posisinya dalam arsitektur secara keseluruhan.</p><p>Ada satu mental model yang menurut saya jauh lebih membantu, yang saya sendiri gunakan.</p><blockquote>Kunci memahami AI infrastructure bukan menghafal istilah atau nama produk NVIDIA. Yang perlu dipahami adalah ke mana data bergerak: GPU-ke-GPU di dalam node, GPU-ke-GPU antar-node, compute-ke-storage, dan compute-ke-user. Setelah aliran data ini jelas, fungsi istilah seperti NVLink, NVSwitch, ConnectX, InfiniBand, Ethernet, RoCE, DPU, dan storage fabric menjadi jauh lebih mudah dipahami.</blockquote><h3>Apa Saja Komponen yang Membentuk AI/HPC Data Center?</h3><p>Secara konsep, sebuah AI/HPC Data Center tidak jauh berbeda dari komputer atau infrastruktur IT yang sudah kita kenal. Bedanya, komponen-komponen tersebut bekerja dalam skala yang jauh lebih besar dan dirancang untuk menangani kebutuhan komputasi yang jauh lebih tinggi.</p><p>Secara sederhana, kita dapat membaginya menjadi beberapa bagian utama:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_cWOOW3nRj3qhwtRZjDJCA.png" /><figcaption>Gambar 1. Komponen HPC</figcaption></figure><p><strong>Compute:</strong> Tempat proses komputasi berlangsung. Di sinilah CPU dan GPU menjalankan workload, seperti training model AI, inference, atau pekerjaan HPC lainnya.</p><p><strong>Storage:</strong> Tempat menyimpan data yang dibutuhkan oleh workload, seperti dataset, model, dan hasil komputasi.</p><p><strong>Network:</strong> Jalur komunikasi yang menghubungkan compute dengan compute lain, storage, user, dan berbagai layanan di dalam data center.</p><p><strong>Management:</strong> Digunakan untuk mengelola workload dan lingkungan cluster, misalnya menjalankan job, melakukan monitoring, atau mengelola resource compute.</p><p><strong>Out-of-Band Management:</strong> Jalur khusus untuk mengelola hardware secara langsung dan terpisah dari network utama. Biasanya dilakukan melalui BMC (Baseboard Management Controller), yang memungkinkan administrator memonitor kondisi server, melakukan power on/off, atau mengakses console meskipun operating system bermasalah.</p><p>Pada tahap ini yang paling penting adalah memahami bahwa sebuah AI/HPC bukan hanya seupulan GPU Server (GPU Cluster), tetapi gabungan beberapa domain yang salin bekerja bersama.</p><h3>Bagaimana Compute, Network, dan Storage Saling Berkomunikasi?</h3><p>Setelah mengetahui komponen utamanya, pertanyaan berikutnya adalah bagaimana semua komponen bisa saling berkomunikasi.</p><p>Secara sederhana, compute menjadi pusat dari semua proses yang ada di dalam AI/HPC Data Center. Compute tidak bekerja sendirian. Ia perlu berkomunikasi dengan compute lain, membaca dan menulis data ke storage, dan terhubung dengan external services.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RHNDnId5lbs_wejx1WMAMA.png" /><figcaption>Gambar 2. Bagaimana semua komponen berinteraksi</figcaption></figure><p>Dari sini kita mulai melihat bahwa sebuah AI/HPC Data Center bukan hanya kumpulan server, tetapi sebuah sistem di mana compute, network, dan storage saling bergantung satu sama lain.</p><p>Dan dari hubungan inilah muncul pertanyaan berikutnya:</p><h3>Lalu Ke Mana Data Bergerak?</h3><p>Dalam sebuah AI/HPC Data Center, ada beberapa pola komunikasi utama:</p><ul><li><strong>GPU ↔ GPU di dalam satu node</strong></li><li><strong>GPU ↔ GPU antar-node</strong></li><li><strong>Compute ↔ Storage</strong></li><li><strong>Compute ↔ User / Application / External Network</strong></li><li><strong>Administrator ↔ Infrastructure Management</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iIVgRROE1Cv4jAW8XSfboA.png" /><figcaption>Gambar 3. <em>Ikuti aliran data untuk membangun mental model AI/HPC Data Center.</em></figcaption></figure><p>Dari pola-pola inilah kebutuhan teknologi mulai muncul.</p><p>Komunikasi GPU di dalam satu node tentu mempunyai kebutuhan yang berbeda dengan komunikasi GPU antar-node. Begitu juga dengan traffic dari compute ke storage, user, atau management.</p><h3>Mulai dari satu Node: Scale-up vs Scale-out</h3><p>Sebelum membahas GPU cluster dengan banyak server, lebih mudah jika kita mulai dari satu compute node terlebih dahulu.</p><p>Bayangkan sebuah server AI yang memiliki beberapa GPU di dalamnya. Agar GPU-GPU tersebut dapat bekerja sebagai satu sistem, mereka membutuhkan jalur komunikasi berkecepatan tinggi di dalam server.</p><p>Salah satu contohnya adalah platform <strong>NVIDIA HGX H100</strong>, yang dapat menghubungkan delapan GPU H100 melalui <strong>NVLink</strong> dan <strong>NVSwitch</strong> dalam satu high-bandwidth GPU domain(<a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/">NVIDIA HGX AI Factory Reference Architecture</a>, <a href="https://docs.nvidia.com/hgx-platforms/fabric-manager-user-guide/index.html">NVIDIA Fabric Manager User Guide</a>). Dari sini lahir dua istilah yang sering tertukar dan bikin bingung:</p><ul><li>Scale-Up: Komunikasi antar GPU di dalam satu node / domain melalui NVLink dan NVSwitch.</li><li>Scale-Out: Komunikasi antar-node melalui network fabric seperti InfiniBand atau Ethernet/RoCE. Pada Reference Architecture (RA) NVIDIA HGX AI Factory, jalur ini disebut sebagai Compute East-West fabric (<a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/network-logical-architecture.html">Network Logical Architecture</a>).</li></ul><p>Perbedaan karakteristik bandwidth antara keduanya cukup besar. NVLink pada H100 menyediakan bandwidth GPU-to-GPU yang sangat tinggi di dalam satu node, sedangkan komunikasi antar-node bergantung pada bandwidth network interface yang tersedia.</p><p>Sebagai gambaran, link network berkecepatan <strong>400 Gb/s</strong> setara dengan sekitar <strong>50 GB/s</strong> secara teoritis. Karena itu, ketika workload mulai melakukan scale-out ke beberapa node, <strong>jumlah NIC, bandwidth per NIC, dan topology network</strong> menjadi sangat penting dalam desain AI infrastructure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6yPUS3CfTj-8Yt64DKeiQw.png" /><figcaption>Gambar 4. Perbedaan scale-up dan scale-out</figcaption></figure><h3>Anatomi Satu Node: GPU dan NIC</h3><p>Setelah memahami perbedaan <strong>scale-up</strong> dan <strong>scale-out</strong>, pertanyaan berikutnya adalah:</p><p>Komponen apa yang membuat sebuah GPU bisa berkomunikasi ke luar node?</p><p>Di sinilah kita perlu membedakan antara <strong>GPU</strong> dan <strong>network adapter</strong>.</p><p><strong>H100/H200 adalah GPU, ConnectX adalah network adapter (NIC).</strong></p><p>H100 adalah GPU, bukan network adapter. Sedangkan ConnectX adalah network adapter. Dokumentasi DGX H100/H200 menunjukan bahwa GPU subsystem dan networking modules adalah hardware yang terpisah (<a href="https://docs.nvidia.com/dgx/dgxh100-user-guide/">NVIDIA DGX H100/H200 User Guide</a>). Namun, server bisa dirancang sehingga NIC tertentu punya affinity/topology yang dekat dengan GPU tertentu, biasanya lewat PCIe switch yang sama. Di Linux, perintah “<em>nvidia-smi topo -m</em>” memperlihatkan pasangan GPU dan NIC ini.</p><blockquote><strong><em>Catatan:</em></strong><em> Implementasi NIC dapat berbeda antar-generasi platform. Pada H100/H200, NIC merupakan komponen terpisah di level server, sedangkan pada generasi yang lebih baru seperti HGX B300, NVIDIA mengintegrasikan ConnectX-8 SuperNIC langsung pada baseboard (</em><a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory/latest/components.html">NVIDIA HGX AI Factory B300</a><em>). Namun secara fungsi, GPU dan NIC tetap merupakan komponen yang berbeda.</em></blockquote><p><strong>Mengapa server HGX H100/H200 punya banyak network adapter?</strong></p><p>Pada desain AI infrastructure skala besar, sebuah server HGX H100/H200 dapat memiliki banyak NIC. Dalam beberapa reference design, jumlah NIC bahkan dibuat sangat dekat dengan jumlah GPU.</p><p>Tujuannya adalah untuk menjaga <strong>bandwidth</strong> dan <strong>topology</strong> agar komunikasi antar-node tidak menjadi bottleneck.</p><p>Pada NVIDIA HGX AI Factory reference node, delapan BlueField-3 B3140H SuperNIC digunakan untuk <strong>Compute East-West Fabric</strong>, masing-masing menyediakan satu port 400 GbE. Selain itu, satu BlueField-3 DPU B3220 dengan dua port 200 GbE digunakan untuk <strong>North-South connectivity</strong> (<a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/networking-hardware.html">Networking Hardware</a>).</p><p>Jadi banyaknya NIC bukan karena setiap GPU secara fundamental wajib memiliki satu NIC, tetapi karena desain tersebut dibuat untuk mencapai target bandwidth dan topology tertentu.</p><p><strong>DGX dan HGX: Serupa, Tetapi Tak Sama.</strong></p><p>DGX adalah complete system dari NVIDIA. HGX adalah accelarated compute platform yang digunakan OEM untuk membangun server AI/HPC mereka (<a href="https://docs.nvidia.com/certification-programs/latest/nvidia-certified-systems.html">NVIDIA-Certified Systems</a>). Dengan kata lain, dua server dengan GPU Board HGX yang bisa memiliki CPU, NIC, storage lokal dan chassis yang berbeda, tergantung vendor yang di gunakan.</p><p>Contohnya seperti Dell, SuperMicro, HPE, dan lainya.</p><h3>Dari Satu Node ke Banyak Node: Leaf-Spine, East-West, dan North-South</h3><p>Ketika sebuah AI workload tidak lagi cukup dijalankan pada satu node, kita mulai menambahkan lebih banyak compute node ke dalam cluster.</p><p>Pada tahap ini, komunikasi tidak lagi hanya terjadi di dalam satu server. GPU pada satu node perlu bertukar data dengan GPU yang berada di node lain.</p><p>Karena itu, komunikasi antar-node membutuhkan <strong>network fabric</strong> yang menghubungkan seluruh compute node melalui switch.</p><p>Pada NVIDIA Reference Architecture, compute network untuk scale-out dirancang sebagai high-performance RDMA fabric dengan arsitektur <strong>leaf-spine</strong>. Dalam desain ini, compute node terhubung ke leaf switch, lalu leaf switch terhubung ke spine switch.</p><p>Arsitektur seperti ini membantu menyediakan banyak jalur komunikasi antar-node dan memudahkan penambahan node baru ketika cluster melakukan scale-out (<a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/network-logical-architecture.html">Network Logical Architecture</a>).</p><p>Pada desain AI/HPC skala besar, topology juga dapat dibuat <strong>rail-optimized</strong>, yaitu NIC atau GPU tertentu diarahkan ke jalur fabric tertentu agar komunikasi antar-node lebih efisien dan predictable (<a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/network-logical-architecture.html">Network Logical Architecture</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lDo8xEdM0cu9EbqIGo50RA.png" /><figcaption>Gambar 5. Leaf-Spine Topology</figcaption></figure><p>Selain topology, ada dua istilah arah traffic yang juga penting untuk dibedakan:</p><ul><li>East-West: trafic antar-computer node.</li><li>Norh-South: trafic dari compute menuju storage, user, atau external services.</li></ul><p>NVIDA membedakan kedua arah trafik di Reference Architecture (RA) nya (<a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/network-logical-architecture.html">Network Logical Architecture</a>).</p><p>Dari sini muncul satu hal penting:</p><blockquote>Network yang digunakan untuk komunikasi GPU antar-node belum tentu sama dengan network yang digunakan untuk mengakses storage.</blockquote><h3>Compute-to-Storage Adalah Masalah yang Berbeda</h3><p>Sampai titik ini, kita banyak membahas komunikasi antar-GPU dan antar-compute node.</p><p>Namun AI/HPC workload juga harus membaca dataset, menulis checkpoint, menyimpan model, dan mengakses shared data.</p><p>Artinya ada jalur komunikasi lain:</p><blockquote>Compute → Storage</blockquote><p>Jalur ini tidak harus menggunakan fabric yang sama dengan GPU scale-out.</p><p>Dalam NVIDIA Reference Architecture, network dapat dipisahkan menjadi beberapa fungsi, seperti <strong>Compute East-West Fabric</strong>, <strong>Converged North-South Fabric</strong>, dan <strong>Out-of-Band Management Fabric</strong> [4].</p><p>Dengan kata lain, sebuah cluster dapat memiliki:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p2P__sSD-W4Lrlo4MZdgQA.png" /><figcaption>Gambar x. Jalur Network</figcaption></figure><p>Implementasinya dapat berbeda tergantung skala dan desain cluster. Pada beberapa desain, sebagian traffic dapat dikonsolidasikan ke fabric yang sama, sementara pada desain yang lebih besar compute dan North-South traffic dapat dipisahkan.</p><p>Yang penting bukan menghafal bahwa storage harus menggunakan network tertentu, tetapi memahami:</p><blockquote>Protocol apa yang digunakan, transport apa yang membawa datanya, dan fabric apa yang berada di bawahnya?</blockquote><p><strong>Contoh Kasus: NFS Over RDMA</strong></p><p>Sebagai contoh, perhatikan konfigurasi Kubernetes StorageClass berikut:</p><pre>➜  ~ kubectl get sc storage-nvme-rdma-c1 -o yaml<br>allowVolumeExpansion: true<br>apiVersion: storage.k8s.io/v1<br>kind: StorageClass<br>metadata:<br>  annotations:<br>    kubectl.kubernetes.io/last-applied-configuration: |<br>      {&quot;allowVolumeExpansion&quot;:true,&quot;apiVersion&quot;:&quot;storage.k8s.io/v1&quot;,&quot;kind&quot;:&quot;StorageClass&quot;,&quot;metadata&quot;:{&quot;annotations&quot;:{},&quot;name&quot;:&quot;storage-nvme-rdma-c1&quot;},&quot;mountOptions&quot;:[&quot;vers=4.1&quot;,&quot;proto=rdma&quot;,&quot;max_connect=16&quot;,&quot;rsize=262144&quot;,&quot;wsize=262144&quot;],&quot;parameters&quot;:{&quot;backendType&quot;:&quot;ontap-nas&quot;,&quot;fsType&quot;:&quot;xfs&quot;,&quot;provisioningType&quot;:&quot;thin&quot;,&quot;storagePools&quot;:&quot;jah1ac12sttirb-nfs01:.*&quot;},&quot;provisioner&quot;:&quot;csi.trident.netapp.io&quot;,&quot;reclaimPolicy&quot;:&quot;Delete&quot;}<br>  creationTimestamp: &quot;2025-06-03T10:15:38Z&quot;<br>  name: storage-nvme-rdma-c1<br>  resourceVersion: &quot;396&quot;<br>  uid: c52101ef7f3f-8d8a-e373-4990-f525fdfe<br>mountOptions:<br>- vers=4.1<br>- proto=rdma<br>- max_connect=16<br>- rsize=262144<br>- wsize=262144<br>parameters:<br>  backendType: ontap-nas<br>  fsType: xfs<br>  provisioningType: thin<br>  storagePools: srv-nfs01:.*<br>provisioner: csi.trident.netapp.io<br>reclaimPolicy: Delete<br>volumeBindingMode: Immediate<br>➜  ~</pre><p>Dari output konfigurasi di atas terlihat seperti backEndType: ontap-nas<em>,</em>vers=4.1, danproto=rdma (backend NetApp Trident di Kubernetes) itu mengarah ke NFSv4.1 over RDMA, bukan otomatis NVME-over Fabrics. NetApp mendokumentasaikan NFS over RDMA pada ONTAP dan penggunaan port berkemapuan RoCE (RDMA over Converged Ethernet) untuk alur ini (<a href="https://docs.netapp.com/us-en/ontap/concepts/rdma-concept.html">NetApp ONTAP: NFS over RDMA</a>, <a href="https://docs.netapp.com/us-en/ontap/nfs-rdma/configure-nics-task.html">NetApp ONTAP: Configure NICs for NFS over RDMA</a>).</p><p>Dari contoh ini kita mendapat satu pelajaran penting:</p><blockquote>Nama sebuah StorageClass tidak selalu menggambarkan protocol yang benar-benar digunakan.</blockquote><p>Walaupun resource memiliki nama seperti storage-nvme-rdma, field konfigurasi menunjukkan bahwa jalurnya adalah <strong>NFS over RDMA</strong>, bukan <strong>NVMe over Fabrics</strong>.</p><p><strong>Contoh Kasus: DDN EXAScaler dan Lustre</strong></p><p>Sekarang lihat contoh yang berbeda. Sebuah StorageClassDDN-EXAScaler pada Kubernetes memiliki konfigurasi seperti berikut:</p><pre>➜  ~ kubectl get sc storage-nvme-lustre-vm -o yaml<br>allowVolumeExpansion: true<br>allowedTopologies:<br>- matchLabelExpressions:<br>  - key: topology.exa.csi.ddn.com/zone<br>    values:<br>    - zone-5<br>apiVersion: storage.k8s.io/v1<br>kind: StorageClass<br>metadata:<br>  annotations:<br>    kubectl.kubernetes.io/last-applied-configuration: |<br>      {&quot;allowVolumeExpansion&quot;:true,&quot;allowedTopologies&quot;:[{&quot;matchLabelExpressions&quot;:[{&quot;key&quot;:&quot;topology.exa.csi.ddn.com/zone&quot;,&quot;values&quot;:[&quot;zone-5&quot;]}]}],&quot;apiVersion&quot;:&quot;storage.k8s.io/v1&quot;,&quot;kind&quot;:&quot;StorageClass&quot;,&quot;metadata&quot;:{&quot;annotations&quot;:{},&quot;name&quot;:&quot;storage-nvme-lustre-vm&quot;},&quot;parameters&quot;:{&quot;bindMount&quot;:&quot;false&quot;,&quot;exaFS&quot;:&quot;10.10.10.11@o2ib1,10.10.10.12@o2ib1:10.10.10.13@o2ib1,10.10.10.14@o2ib1:10.10.10.15@o2ib1,10.10.10.16@o2ib1:10.10.10.17@o2ib1,10.10.10.18@o2ib1:/scratch&quot;,&quot;exaMountUid&quot;:&quot;110&quot;},&quot;provisioner&quot;:&quot;exa.csi.ddn.com&quot;}<br>  creationTimestamp: &quot;2025-06-03T10:15:38Z&quot;<br>  name: storage-nvme-lustre-vm<br>  resourceVersion: &quot;404&quot;<br>  uid: 934f0feed6e1-4de6-72d3-92a9-3d3fb1bf<br>parameters:<br>  bindMount: &quot;false&quot;<br>  exaFS: 10.10.10.11@o2ib1,10.10.10.12@o2ib1:10.10.10.13@o2ib1,10.10.10.14@o2ib1:10.10.10.15@o2ib1,10.10.10.16@o2ib1:10.10.10.17@o2ib1,10.10.10.18@o2ib1:/scratch<br>  exaMountUid: &quot;107&quot;<br>provisioner: exa.csi.ddn.com<br>reclaimPolicy: Delete<br>volumeBindingMode: Immediate<br>➜  ~</pre><p>Pada Lustre, LNet adalah network transport layer, sedangkan o2ib berkaitan dengan transport OFED/RDMA. Dokumentasi Lustre menjelaskan bahwa o2ibumum dipakai pada RDMA fabric dan sering diasosiasikan dengan InfiniBand tetapi pada implementasi tertentu juga dapat terkait dengan RoCE (<a href="https://wiki.lustre.org/Lustre_Networking_%28LNET%29_Overview">Lustre Networking Overview</a>, <a href="https://wiki.lustre.org/Lustre_Architecture_for_Admins">Lustre Architecture for Admins</a>).</p><p>NFS over RDMA dan Lustre sama-sama dapat memanfaatkan RDMA, tetapi menggunakan protocol, software stack, dan bahkan physical fabric yang berbeda.</p><p>Dan dari sini kita mulai melihat mengapa sebuah AI/HPC node dapat memiliki <strong>lebih dari satu network plane</strong>.</p><h3>Satu Node, Beberapa Network Plane</h3><p>Pada node modern, trafic compute scale-out, storage, management, dan OOB bisa berada pada plane yang berbeda, Reference Architecture (RA) NVIDIA HGX AI Factory secara eksplisit memisahkan tigaa farbric: <em>Compute East-West, Converged North-South, dan OOB (</em><a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/network-logical-architecture.html">Network Logical Architecture</a>, <a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/networking-hardware.html">Networking Hardware</a><em>).</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mFHcFCmTGS1sDP0QVLeC6w.png" /><figcaption>Gambar 6. Network Plane AI/HPC Infrastructure</figcaption></figure><p>Pemisahan ini penting karena setiap jenis traffic memiliki kebutuhan yang berbeda.</p><ul><li><strong>Compute East-West</strong> digunakan untuk komunikasi antar-compute node.</li><li><strong>Converged North-South</strong> digunakan untuk traffic menuju storage, user, atau external services.</li><li><strong>OOB Fabric</strong> digunakan untuk management hardware secara terpisah dari jalur data utama.</li></ul><p>Dengan kata lain, satu node AI/HPC modern tidak hanya memiliki “satu network”, tetapi bisa memiliki <strong>beberapa network plane</strong> dengan fungsi yang berbeda.</p><p><strong>Logical Network Tidak Sama dengan Adapter, Port, atau Kabel</strong></p><p>Dalam menjalankan infrastruktur AI yang besar, jumlah logical network tidak otomatis sama dengan jumlah adapter, port , link atau kabel pada node. Contohnya yaitu DGX H100 yang memiliki 8 ConnectX-7 untuk compute fabric keluar melalui empat port OSFP, karena satu cage OSFP dapat membawa dua port 400GBE (<a href="https://docs.nvidia.com/dgx-basepod/reference-architecture-infrastructure-foundation-enterprise-ai/latest/core-components.html">NVIDIA DGX BasePOD: Core Components</a>, <a href="https://docs.nvidia.com/networking/display/400G100GPAM4Ovpub/Linking-DGXs,-Switches,-ConnectX-7-&amp;-ConnectX-8-Adapters,-and-BlueField-3-DPUs-Overview">User Guide for 400G OSFP &amp; QSFP112 Cables and Transceivers</a>). Selain itu ada dua kartu ConnectX-7 dual-port untuk storage dan in-band management, serta satu port OOB untuk BMC (<a href="https://docs.nvidia.com/dgx-basepod/reference-architecture-infrastructure-foundation-enterprise-ai/latest/core-components.html">NVIDIA DGX BasePOD: Core Components</a>, <a href="https://docs.nvidia.com/networking/display/400G100GPAM4Ovpub/Linking-DGXs,-Switches,-ConnectX-7-&amp;-ConnectX-8-Adapters,-and-BlueField-3-DPUs-Overview">User Guide for 400G OSFP &amp; QSFP112 Cables and Transceivers</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TSBI-VzAV9TLihrLaznpJQ.png" /><figcaption>Gambar 7. DGX H100 Node</figcaption></figure><p>Artinya, ketika kita melihat sebuah node AI/HPC, kita tidak bisa langsung menyimpulkan kebutuhan networking hanya dari jumlah GPU yang ada di dalamnya.</p><p><strong>Format HGX Reference by NVIDIA</strong></p><p>NVIDIA mendefinisikan format HGX Reference Configuration sebagai :</p><blockquote>CPU → GPU → Network Adapter → Average GPU Network Bandwidth</blockquote><p>(<a href="https://docs.nvidia.com/certification-programs/latest/nvidia-certified-systems.html">NVIDIA-Certified Systems</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uTvF4B5CjFGefQpz8Pa45g.png" /><figcaption>Gambar 8. HGX Reference by NVIDIA</figcaption></figure><p>Format ini membantu kita memahami bahwa desain HGX tidak hanya berbicara tentang jumlah GPU, tetapi juga tentang <strong>kepadatan network adapter</strong> dan <strong>bandwidth keluar dari node</strong>.</p><p><strong>Bagaimana dengan BMC?</strong></p><p>Selain compute, storage, dan management traffic, masih ada satu jalur lain yang sering terlupakan, yaitu <strong>BMC</strong>.</p><p>BMC berada pada jalur <strong>Out-of-Band Management</strong>, yaitu jalur management hardware yang terpisah dari network utama. Pada NVIDIA Reference Architecture, OOB fabric memang dipisahkan sebagai jalur management tersendiri (<a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/networking-hardware.html">Networking Hardware</a>).</p><p>Jalur ini biasanya digunakan untuk:</p><ul><li>power control,</li><li>hardware health monitoring,</li><li>remote console,</li><li>dan management server di level hardware.</li></ul><p>Dengan kata lain, BMC bukan bagian dari compute fabric maupun storage fabric, melainkan bagian dari infrastruktur management.</p><p><strong>Berapa banyak kabel yang keluar dari satu node?</strong></p><p>Setelah memahami compute fabric, storage fabric, management network, dan OOB management, kita mulai bisa menjawab pertanyaan yang sering muncul:</p><blockquote><em>“Satu HGX node sebenarnya punya berapa kabel network?”</em></blockquote><p>Jawabannya tidak bisa ditentukan hanya dari jumlah GPU. Misalnya sebuah server mempunyai 8 GPU, ini bukan berarti 8 GPU = 8 Kabel alasannya karena ada beberapa level yang harus dibedakan:</p><blockquote>Logical traffic →Network adapter →Network port / link →Physical connector →Cable / transceiver</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KNUSRm74Q8OojQSKKIxjfg.png" /><figcaption>Gamaba 9. Kebutuhan Logic Jaringan AI/HPC</figcaption></figure><p>Baru setelah itu kita melihat bagaimana vendor atau OEM mengimplementasikan kebutuhan tersebut secara fisik.</p><p>Ada desain yang mengonsolidasikan beberapa fungsi melalui DPU. Ada desain yang memisahkan compute, storage, dan management ke adapter yang berbeda. Ada pula desain yang menggunakan breakout connector sehingga jumlah link logical tidak sama dengan jumlah connector yang terlihat dari luar chassis.</p><h3>Tips Cara Menentukan Kebutuhan Arsitektur AI/HPC Data Center untuk GPU Cluster</h3><p>Sebelum menentukan komponen GPU cluster, kita perlu memahami kebutuhan arsitekturnya terlebih dahulu. Kesalahan dalam memilih topology, network, atau komponen dapat meningkatkan biaya sekaligus menurunkan performa sistem:</p><ul><li>Pahami jumlah GPU yang digunakan per node.</li><li>Pahami scale-up GPU di dalam node.</li><li>Pahalmi scale-out GPU antar-node.</li><li>Identifikasi compute fabric.</li><li>Identifikasi jalur storage.</li><li>Pisahkan user/application network.</li><li>Pisahkan OOB management.</li><li>Baru hitung dan kalkulasi berapa NIC, Port, Switch, dan Kabel yang di gunakan.</li></ul><p>Dengan urutan seperti ini, kita tidak memilih hardware terlebih dahulu lalu mencoba menyesuaikan workload ke dalamnya.</p><p>Sebaliknya, <strong>hardware dipilih berdasarkan traffic yang memang harus dilayani</strong>.</p><h3>Mental Model Akhir: Follow the Data</h3><p>Setelah melihat arsitektur AI/HPC dari sudut pandang aliran data, berbagai teknologi yang sebelumnya terlihat seperti kumpulan istilah mulai mempunyai tempatnya masing-masing.</p><p><strong>NVLink</strong><br>Menyediakan high-bandwidth interconnect untuk komunikasi GPU di dalam satu node atau scale-up domain.</p><p><strong>NVSwitch</strong><br>Menyediakan switching fabric yang memungkinkan GPU di dalam scale-up domain berkomunikasi dengan bandwidth tinggi.</p><p><strong>ConnectX / SuperNIC</strong><br>Menjadi network interface yang menghubungkan compute node dengan scale-out network.</p><p><strong>InfiniBand</strong><br>Merupakan high-performance network fabric yang banyak digunakan untuk workload HPC dan AI karena menawarkan bandwidth tinggi, latency rendah, dan dukungan RDMA.</p><p><strong>Ethernet</strong><br>Dapat digunakan untuk general-purpose networking maupun high-performance network fabric.</p><p><strong>RoCE</strong><br>Memungkinkan komunikasi RDMA berjalan di atas Ethernet.</p><p><strong>GPUDirect RDMA</strong><br>Memungkinkan perangkat RDMA-capable seperti NIC mengakses GPU memory secara lebih langsung, sehingga data tidak perlu selalu melalui staging di host memory.</p><p><strong>DPU</strong><br>Dapat menangani atau meng-offload sebagian infrastructure services seperti networking, security, dan storage processing dari host CPU.</p><p><strong>Lustre</strong><br>Merupakan parallel filesystem yang banyak digunakan untuk workload HPC dan AI dengan kebutuhan shared storage berperforma tinggi.</p><p><strong>NFS</strong><br>Menyediakan shared file access. Secara umum NFS berjalan di atas TCP, tetapi pada implementasi tertentu juga dapat menggunakan RDMA untuk meningkatkan efisiensi transfer data.</p><h3><strong>Referensi</strong></h3><p><strong>Arsitektur dan perangkat keras NVIDIA</strong></p><ul><li><a href="https://docs.nvidia.com/certification-programs/latest/nvidia-certified-systems.html">NVIDIA-Certified Systems: definisi HGX dan format konfigurasi 2–8–9–400</a></li><li><a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/">NVIDIA HGX AI Factory (HGX H100, H200, B200) Reference Architecture</a></li><li><a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/network-logical-architecture.html">Network Logical Architecture (HGX AI Factory)</a></li><li><a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory-h100-h200-b200/latest/networking-hardware.html">Networking Hardware (HGX AI Factory)</a></li><li><a href="https://docs.nvidia.com/enterprise-reference-architectures/white-paper.pdf">NVIDIA Enterprise Reference Architectures</a></li><li><a href="https://docs.nvidia.com/dgx/dgxh100-user-guide/">NVIDIA DGX H100/H200 User Guide</a></li><li><a href="https://docs.nvidia.com/hgx-platforms/fabric-manager-user-guide/index.html">NVIDIA Fabric Manager User Guide</a></li><li><a href="https://docs.nvidia.com/enterprise-reference-architectures/white-paper/latest/reference-architectures-deep-dive.html">NVIDIA Reference Architectures: Deep Dive</a></li><li><a href="https://docs.nvidia.com/dgx-basepod/reference-architecture-infrastructure-foundation-enterprise-ai/latest/core-components.html">NVIDIA DGX BasePOD: Core Components</a></li><li><a href="https://docs.nvidia.com/networking/display/400G100GPAM4Ovpub/Linking-DGXs,-Switches,-ConnectX-7-&amp;-ConnectX-8-Adapters,-and-BlueField-3-DPUs-Overview">User Guide for 400G OSFP &amp; QSFP112 Cables and Transceivers</a></li><li><a href="https://docs.nvidia.com/enterprise-reference-architectures/hgx-ai-factory/latest/components.html">NVIDIA HGX AI Factory B300</a></li></ul><p><strong>Jaringan dan RDMA</strong></p><ul><li><a href="https://docs.nvidia.com/networking/display/ConnectX7Firmwarev28341002/Firmware%2BCompatible%2BProducts">ConnectX-7 Firmware Compatible Products</a></li><li><a href="https://docs.nvidia.com/networking-ethernet-software/guides/EVPN-Network-Reference/Additional-Information/">NVIDIA RoCE documentation</a></li></ul><p><strong>Storage</strong></p><ul><li><a href="https://docs.netapp.com/us-en/ontap/concepts/rdma-concept.html">NetApp ONTAP: NFS over RDMA</a></li><li><a href="https://docs.netapp.com/us-en/ontap/nfs-rdma/configure-nics-task.html">NetApp ONTAP: Configure NICs for NFS over RDMA</a></li><li><a href="https://wiki.lustre.org/Lustre_Networking_%28LNET%29_Overview">Lustre Networking Overview</a></li><li><a href="https://wiki.lustre.org/Lustre_Architecture_for_Admins">Lustre Architecture for Admins</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e332a4d6d43" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>