---
title: "Membangun Mesin Pengembangan Kubernetes secara Local dengan Lima-vm"
description: "Mesin Pengembangan adalah salah satu perkakas yang bisa digunakan oleh\nPengembang untuk mendapatkan feedback dari apa yang sedang dikerjakan. Dengan\ncatatan mesin ini bisa berjalan di Laptop/Komputer ..."
publishedAt: 2025-04-12
locale: id
urlSlug: membangun-local-kubernetes-development-dengan-lima-vm
isDraft: false
defaultLocale: en
---
[TOC]

## What?

Mesin Pengembangan adalah salah satu perkakas yang bisa digunakan oleh
Pengembang untuk mendapatkan feedback dari apa yang sedang dikerjakan. Dengan
catatan mesin ini bisa berjalan di Laptop/Komputer secara _Local_, tentunya
dengan sumber daya yang memadai.

Diharapkan dengan Mesin ini yang tersedia di local, dapat meningkatkan jumlah
iterasi dan feedback yang didapat menjadi lebih sering.

Dengan mendapatkan _feedback_ yang sering, pengembang dapat melakukan beberapa
iterasi yang disebut _Inner loop_ secara mandiri. Setelah cukup percaya diri,
pekerjaan bisa diteruskan ke anggota Tim yang lain untuk melalui iterasi lain
seperti Testing, Bug fixing dll, yang disebut _Outer loop_, berikut ilustrasi
yang diambil dari blog
[Sourcegraph](https://sourcegraph.com/blog/developer-productivity-thoughts).

![Inner loop and Outer loop](https://cdn.prod.website-files.com/6750d0c3f154999a486dade7/67a9b6e6f0fe04e8eab1bf23_Image%202-10-25%20at%201.20%E2%80%AFAM.avif)

## Why?

Sebagai pengembang yang sehari-hari berinteraksi dengan aplikasi yang di deploy
di Kubernetes, ada baik-nya untuk mendekatkan diri dengan teknologi yang satu
ini.

Inilah salah satu alasan saya untuk membuat sebuah "Development Box" yang
terisolasi berupa virtual machine. Dan berisikan beberapa tools terkait untuk
belajar Kubernetes.

Sebelum-nya saya menggunakan
[Multipass.run](belajar-virtual-machine-multipass) dan Microk8s,
namun kali ini mari kita coba untuk eksplorasi
[Kind](https://github.com/kubernetes-sigs/kind) dengan
[Lima-vm](https://github.com/lima-vm/lima).

## How?

Instalasi Lima-vm bisa mengikuti tulisan saya sebelum-nya
[disini](install-warp-client-fedora-desktop), selain itu ada beberapa
tools lain yang perlu di-install.

### Membuat vm dengan template Docker

```bash
limactl start template://docker
```

Tambahkan flag `--rosetta` jika menggunakan Chip Apple silicon dan ingin
menjalankan container berbasis x86.

### Instalasi CLI tool

Install cli tools berikut ini sudah terinstal di-dalam Lima-vm docker, berikut
cara instalasi-nya

1. [Kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/)
2. [Kind](https://kind.sigs.k8s.io/docs/user/quick-start/#installation)
3. [Ctlptl](https://github.com/tilt-dev/ctlptl?tab=readme-ov-file#how-do-i-install-it)

### Membuat Kind cluster dengan Ctlptl

Sebelum-nya pastikan sudah berada di dalam Lima-vm docker

```bash
limactl shell docker
```

Buat file kind.yaml

```yaml
---
apiVersion: ctlptl.dev/v1alpha1
kind: Registry
name: ctlptl-registry
port: 5005
---
apiVersion: ctlptl.dev/v1alpha1
kind: Cluster
product: kind
registry: ctlptl-registry
kindV1Alpha4Cluster:
    name: my-cluster
    nodes:
        - role: control-plane
        - role: worker
```

Mengapa menggunakan [Ctlptl](https://github.com/tilt-dev/ctlptl) ? karena ctlptl
dapat membuat cluster berdasarkan config file, yang nanti akan berguna jika
ingin berbagi config dengan anggota tim yang lain.

Cluster config diatas sudah mencakup local registry jika kita ingin build local
image, push image tersebut ke local registry yang bisa dipull oleh Kind cluster.
Beberapa contoh definisi ctlptl bisa lihat di repo
[ini](https://github.com/tilt-dev/ctlptl/tree/main/examples).

Namun iterasi yang lebih nyaman untuk workflow diatas saya sarankan dijalankan
bersama [Tilt.dev](https://tilt.dev), yang mana akan dibahas di artikel
selanjutnya.

Buat cluster dengan perintah berikut.

```bash
jimbo@lima-docker:~/hello-podinfo$ ctlptl apply -f kind.yaml
Creating registry "ctlptl-registry"...
registry.ctlptl.dev/ctlptl-registry created
No kind clusters found.
Creating cluster "my-cluster" ...
 ✓ Ensuring node image (kindest/node:v1.32.2) 🖼
 ✓ Preparing nodes 📦 📦
 ✓ Writing configuration 📜
 ✓ Starting control-plane 🕹️
 ✓ Installing CNI 🔌
 ✓ Installing StorageClass 💾
 ✓ Joining worker nodes 🚜
Set kubectl context to "kind-my-cluster"
You can now use your cluster with:

kubectl cluster-info --context kind-my-cluster

Thanks for using kind! 😊
   Connecting kind to registry ctlptl-registry
Switched to context "kind-my-cluster".
 🔌 Connected cluster kind-my-cluster to registry ctlptl-registry at localhost:5005
 👐 Push images to the cluster like 'docker push localhost:5005/alpine'
cluster.ctlptl.dev/kind-my-cluster created
```

Pastikan sudah terkoneksi dengan Kind cluster

```bash
jimbo@lima-docker:~/hello-podinfo$ kubectl cluster-info
Kubernetes control plane is running at https://127.0.0.1:34881
CoreDNS is running at https://127.0.0.1:34881/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
```

Dari definisi cluster Ctlptl pada file `kind.yaml` diatas, kita dapat
definisikan cluster terdiri dari 1 server dan 1 worker. Kita bisa pastikan
dengan perintah `kubecl get nodes`

```bash
jimbo@lima-docker:~/hello-podinfo$ kubectl get nodes
NAME                       STATUS   ROLES           AGE   VERSION
my-cluster-control-plane   Ready    control-plane   40m   v1.32.2
my-cluster-worker          Ready    <none>          40m   v1.32.2
```

### Deploy Demoapp ke cluster Kind

Buatlah file `demoapp.yaml` dengan isi sbb.

```yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:
    name: demoapp
spec:
    replicas: 1
    selector:
        matchLabels:
            app: demoapp
    template:
        metadata:
            labels:
                app: demoapp
        spec:
            containers:
                - name: demoapp
                  image: docker.io/hashicorp/demo-webapp-lb-guide
                  ports:
                      - containerPort: 9898
                  env:
                      - name: PORT
                        value: "9898"
                      - name: HOST_IP
                        valueFrom:
                            fieldRef:
                                fieldPath: status.podIP
```

Execute deployment dengan kubectl

```bash
jimbo@lima-docker:~/hello-podinfo$ kubectl apply -f demoapp.yaml
deployment.apps/demoapp created
```

Tunggu hingga deployment ready

```bash
jimbo@lima-docker:~/hello-podinfo$ kubectl get deployments --watch
NAME      READY   UP-TO-DATE   AVAILABLE   AGE
demoapp   0/1     1            0           35s
demoapp   1/1     1            1           45s
```

Get nama pod yang ingin kita testing, bisa pakai command berikut.

```bash
jimbo@lima-docker:~/hello-podinfo$ kubectl get pods
NAME                       READY   STATUS    RESTARTS   AGE
demoapp-6c66595c9f-bnjsw   1/1     Running   0          6m14s
```

Lakukan port-forward untuk bisa mengakses pod tersebut.

```bash
jimbo@lima-docker:~/hello-podinfo$ kubectl port-forward pod/demoapp-6c66595c9f-bnjsw 9090:9898
Forwarding from 127.0.0.1:9090 -> 9898
Forwarding from [::1]:9090 -> 9898
```

Coba kirim request ke pod dengan `curl`, kamu bahkan bisa request dari host
machine karena Lima-vm sudah support automatic port forwarding.

```bash
jimbo@host:~$ curl http://localhost:9090
Welcome! You are on node 10.244.1.4:9898
```

## Kesimpulan

Kebiasaan saya di Windows menggunakan WSL bisa saya replikasi juga di lingkungan
Macos/Linux dengan Lima-vm. Kita bisa melakukan iterasi pengembangan/eksperimen
dengan lebih leluasa tanpa khawatir tidak sengaja mengganggu host/machine utama
yang kita gunakan sehari-hari karena sudah ter-isolasi dalam sebuah virtual
machine.

Terimakasih untuk semua creator, maintainer dari semua tools diatas, Kualitas
hidup saya menjadi lebih baik!