46 Pertanyaan dan Jawaban Wawancara Kubernetes Teratas pada 2026

Pertanyaan Wawancara Kubernetes Dasar

Mari mulai dengan pertanyaan wawancara Kubernetes tingkat dasar. Pertanyaan-pertanyaan ini mencakup pengetahuan fondasional yang diperlukan untuk memahami dan bekerja dengan Kubernetes.

1. Apa itu Pod di Kubernetes?

Pod adalah unit terkecil yang dapat didistribusikan di Kubernetes. Pod merepresentasikan satu atau beberapa kontainer yang berjalan dalam lingkungan bersama. Kontainer di dalam sebuah Pod berbagi sumber daya jaringan dan penyimpanan.

Berikut contoh sederhana berkas YAML definisi Pod:

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

2. Apa tujuan kubectl?

Kubectl adalah alat CLI utama untuk mengelola sumber daya Kubernetes dan berinteraksi dengan klaster. Berikut beberapa perintah kubectl umum yang perlu Anda ketahui:

kubectl get pods 				 # list all Pods
kubectl get services 			 # list all Services
kubectl logs <pod-name> 	  	 # view logs of a Pod
kubectl exec -it <pod-name> – /bin/sh # open a shell inside a Pod

3. Apa itu Deployment di Kubernetes?

Deployment di Kubernetes adalah abstraksi tingkat lebih tinggi yang mengelola siklus hidup Pod. Deployment memastikan jumlah replika yang diinginkan aktif dan berjalan serta menyediakan fitur seperti rolling update, rollback, dan self-healing.

Berikut contoh berkas YAML definisi Deployment sederhana:

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

4. Apa itu Service di Kubernetes, dan mengapa dibutuhkan?

Service di Kubernetes mengekspos sekelompok Pod dan memungkinkan komunikasi antarpod maupun ke Pod tersebut.

Karena Pod bersifat ephemeral, IP-nya dapat berubah, sehingga aplikasi yang berkomunikasi dengan Pod juga harus mengubah alamat IP. Karena itu, Service menyediakan endpoint jaringan yang stabil dengan alamat IP tetap.

Contoh sederhana definisi YAML Service:

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

Service di atas meneruskan trafik ke Pod yang memiliki label app: my-app.

5. Jenis layanan apa yang tersedia pada Kubernetes Services?

Kubernetes menyediakan empat jenis utama Service, masing-masing melayani tujuan jaringan yang berbeda:

• ClusterIP (default): Memungkinkan komunikasi internal Pod. Hanya dapat diakses dari dalam klaster.
• NodePort: Mengekspos Service pada port statis setiap Node, sehingga dapat diakses dari luar klaster.
• LoadBalancer: Menggunakan load balancer eksternal milik penyedia cloud. Service kemudian dapat diakses melalui IP publik.
• ExternalName: Memetakan Service Kubernetes ke hostname eksternal.

6. Apa peran ConfigMaps dan secret di Kubernetes?

ConfigMap menyimpan data konfigurasi yang tidak sensitif, sedangkan secret menyimpan data sensitif seperti kunci API dan kata sandi.

Menggunakan secret memungkinkan Anda menghindari menaruh informasi rahasia dalam kode aplikasi. Sebaliknya, ConfigMap memungkinkan aplikasi lebih mudah dikonfigurasi, karena nilai-nilai ini dapat dengan mudah diedit dan tidak perlu dipersistenkan dalam kode aplikasi Anda.

Contoh definisi YAML ConfigMap:

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config
data:
  database_url: "postgres://db.example.com"

Contoh definisi YAML secret (dengan data yang dikodekan base64 [bukan dienkripsi]):

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
data:
  password: cGFzc3dvcmQ=  # "password" encoded in Base64

7. Apa itu Namespace di Kubernetes?

Namespace adalah klaster virtual di dalam sebuah klaster Kubernetes. Namespace membantu mengorganisasi beban kerja di lingkungan multi-penyewa dengan mengisolasi sumber daya dalam satu klaster.

Di bawah ini, Anda dapat menemukan potongan kode singkat yang menunjukkan cara membuat Namespace menggunakan kubectl serta membuat dan mengambil Pod di Namespace tersebut:

# create a namespace called “dev”
kubectl create namespace dev

# create a Pod in that namespace
kubectl run nginx --image=nginx --namespace=dev

# get Pods in that namespace
kubectl get pods --namespace=dev

8. Apa itu Label dan Selector di Kubernetes?

Label adalah pasangan key/value yang dilekatkan pada objek (misalnya Pod). Label membantu mengorganisasi objek Kubernetes. Selector memfilter sumber daya berdasarkan Label.

Berikut contoh Pod yang memiliki label environment: production dan app: nginx:

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

Anda sekarang dapat menggunakan label selector berikut untuk mengambil semua Pod yang memiliki label environment: production:

kubectl get pods -l environment=production

9. Apa itu Persistent Volume (PV) dan Persistent Volume Claim (PVC)?

Persistent Volume (PV) menyediakan penyimpanan yang bertahan melewati siklus hidup Pod. PV adalah bagian penyimpanan di klaster yang telah disediakan oleh administrator klaster atau disediakan secara dinamis menggunakan StorageClass.

Persistent Volume Claim (PVC) adalah permintaan penyimpanan oleh pengguna.

Berikut contoh definisi YAML PV dan PVC:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  hostPath:
    path: "/mnt/data"

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Pertanyaan Wawancara Kubernetes Tingkat Menengah

Setelah berlatih dasar-dasarnya, kita dapat beralih ke pertanyaan tingkat menengah. Memahami konsep seperti jaringan, keamanan, manajemen sumber daya, dan troubleshooting sangat penting pada level ini.

10. Apa itu jaringan Kubernetes, dan bagaimana cara kerjanya?

Jaringan Kubernetes memungkinkan komunikasi antara Pod, Service, dan klien eksternal. Kubernetes mengikuti struktur jaringan datar, artinya secara default semua Pod dapat saling berkomunikasi.

Konsep jaringan kunci di Kubernetes meliputi:

• Komunikasi pod-ke-pod: Setiap Pod mendapatkan IP unik dan dapat berkomunikasi dalam klaster.
• Komunikasi service-ke-pod: Service menyediakan endpoint jaringan stabil untuk sekelompok Pod, karena Pod bersifat ephemeral. Setiap pod mendapat IP baru setiap kali dibuat.
• Ingress controller: Mengelola trafik HTTP/HTTPS eksternal.
• Network policy: Mendefinisikan aturan untuk membatasi atau mengizinkan komunikasi antarpod.

11. Apa itu Role-Based Access Control (RBAC) di Kubernetes?

RBAC adalah mekanisme keamanan yang membatasi pengguna dan layanan berdasarkan izin yang dimiliki. RBAC terdiri dari:

• Role dan ClusterRole: Mendefinisikan tindakan yang diizinkan pada sumber daya.
• RoleBinding dan ClusterRoleBinding: Menetapkan peran kepada pengguna atau service account.

YAML berikut menunjukkan contoh role yang hanya mengizinkan akses baca ke Pod:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
rules:
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["get", "watch", "list"]

Role pod-reader ini sekarang dapat diikat ke pengguna menggunakan RoleBinding:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: pod-reader-binding
subjects:
  - kind: User
    name: dummy
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

12. Bagaimana cara kerja autoscaling di Kubernetes?

Kubernetes menyediakan tiga jenis autoscaling untuk mengoptimalkan penggunaan sumber daya:

1. Horizontal Pod Autoscaler (HPA): Menyesuaikan jumlah Pod berdasarkan penggunaan CPU, memori, atau metrik kustom.
2. Vertical Pod Autoscaler (VPA): Menyesuaikan permintaan CPU dan memori untuk Pod individual.
3. Cluster Autoscaler: Menyesuaikan jumlah worker node dalam klaster berdasarkan kebutuhan sumber daya.

Anda dapat membuat HPA menggunakan kubectl:

kubectl autoscale deployment nginx --cpu-percent=50 --min=1 --max=10

Perintah di atas membuat HPA untuk Deployment bernama nginx dan mencoba menjaga rata-rata utilisasi CPU di seluruh Pod sebesar 50%, dengan jumlah replika minimum 1 dan maksimum 10.

13. Bagaimana Anda melakukan debug terhadap Pod Kubernetes?

Saat Pod gagal, Kubernetes menyediakan beberapa cara untuk melakukan debug:

• Gunakan kubectl logs untuk memeriksa log kontainer dan menemukan kesalahan.
• Gunakan kubectl describe pod untuk meninjau event dan perubahan status terbaru.
• Gunakan kubectl exec untuk membuka shell interaktif dan menyelidiki dari dalam kontainer.
• Gunakan kubectl get pods --field-selector=status.phase=Failed untuk membuat daftar semua Pod yang gagal.

# get logs of a specific Pod
kubectl get logs <pod-name>

# describe the Pod and check events
kubectl describe pod <pod-name>

# open an interactive shell inside the Pod
kubectl exec -it <pod-name> – /bin/sh

# check all failing pods
kubectl get pods --field-selector=status.phase=Failed

Perintah-perintah ini membantu mengidentifikasi miskonfigurasi, keterbatasan sumber daya, atau kesalahan aplikasi.

14. Bagaimana Anda melakukan rolling update dan rollback di Kubernetes?

Deployment Kubernetes mendukung rolling update untuk menghindari downtime. Anda dapat melakukan rolling update dengan mengedit Deployment atau secara eksplisit mengatur imagenya ke versi baru menggunakan:

kubectl set image deployment/my-deployment nginx=nginx:1.21

Anda kemudian dapat memeriksa status Deployment:

kubectl rollout status deployment my-deployment

Jika ingin kembali ke versi sebelumnya, jalankan:

kubectl rollout undo deployment my-deployment

15. Apa itu Ingress di Kubernetes, dan bagaimana cara kerjanya?

Ingress adalah objek API yang mengelola akses HTTP/HTTPS eksternal ke Service di dalam klaster Kubernetes. Ingress memungkinkan pengalihan permintaan berdasarkan hostname dan path, bertindak sebagai reverse proxy untuk banyak aplikasi.

Contoh definisi YAML Ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
    - host: my-app.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: my-service
                port:
                  number: 80

16. Apa itu Kubernetes Gateway API, dan apa bedanya dengan Ingress?

Gateway API adalah evolusi modern jaringan Kubernetes yang bertujuan menggantikan Ingress standar. Sementara Ingress dirancang untuk routing HTTP sederhana, Ingress menjadi terbatas dan terfragmentasi seiring semakin kompleksnya klaster.

Gateway API meningkatkan hal ini dengan:

• Desain berorientasi peran: Memisahkan definisi Gateway (dikelola oleh engineer infrastruktur) dari Route (dikelola oleh developer aplikasi).
• Dukungan yang lebih baik: Dukungan native untuk fitur trafik tingkat lanjut seperti pembagian trafik (A/B testing), pencocokan header, dan jaringan multiklaster tanpa perlu anotasi kustom yang kompleks.

17. Bagaimana Kubernetes menangani limit dan request sumber daya?

Kubernetes memungkinkan Anda menetapkan request dan limit sumber daya untuk Pod guna menjamin alokasi yang adil dan menghindari penggunaan berlebihan sumber daya klaster.

• Request adalah jumlah minimum CPU dan memori yang dibutuhkan Pod. Request ini secara permanen dialokasikan ke Pod.
• Limit adalah jumlah maksimum yang dapat digunakan Pod. Limit tidak langsung dialokasikan, tetapi jika Pod membutuhkan lebih banyak sumber daya, ia dapat tumbuh hingga mencapai limit tersebut.

Contoh YAML definisi Pod yang menetapkan request dan limit sumber daya:

apiVersion: v1
kind: Pod
metadata:
  name: resource-limited-pod
spec:
  containers:
    - name: my-container
      image: nginx
      resources:
        requests:
          memory: "256Mi"
          cpu: "250m"
        limits:
          memory: "512Mi"
          cpu: "500m"

18. Apa yang terjadi jika kebutuhan sumber daya Pod melebihi limit yang ditetapkan?

Jika konsumsi memori Pod melebihi limit memori yang ditetapkan, Kubernetes akan segera mematikan kontainer dengan error out of memory (OOM). Kontainer akan memulai ulang jika kebijakan restart ditetapkan.

Berbeda dengan memori, jika Pod melebihi limit CPU yang ditetapkan, Pod tidak akan dimatikan. Sebaliknya, Kubernetes akan melakukan throttling CPU, sehingga aplikasi melambat.

19. Apa itu init container, dan kapan sebaiknya digunakan?

Init container adalah kontainer khusus yang berjalan sebelum kontainer utama dimulai. Init container membantu menyiapkan lingkungan dengan memeriksa dependensi, memuat berkas konfigurasi, atau menyiapkan data.

Salah satu contohnya adalah init container yang menunggu database siap dan berjalan:

apiVersion: v1
kind: Pod
metadata:
  name: app-with-init
spec:
  initContainers:
    - name: wait-for-db
      image: busybox
      command: ['sh', '-c', 'until nc -z db-service 5432; do sleep 2; done']
  containers:
    - name: my-app
      image: my-app-image

20. Bagaimana Kubernetes menangani gangguan Pod dan ketersediaan tinggi?

Kubernetes memastikan ketersediaan tinggi melalui Pod Disruption Budget (PDB), aturan anti-affinity, dan mekanisme self-healing. Berikut cara kerja mekanisme tersebut:

• Pod Disruption Budget (PDB): Memastikan jumlah minimum Pod tetap tersedia selama gangguan sukarela (misalnya pembaruan klaster saat node perlu diskalakan turun).
• Pod affinity dan anti-affinity: Mengontrol Pod mana yang dapat dijadwalkan bersama atau terpisah.
• Node selector dan Taint/Toleration: Mengontrol bagaimana beban kerja didistribusikan di seluruh Node.

Berikut contoh definisi YAML PDB yang memastikan setidaknya dua Pod tetap berjalan selama gangguan:

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: my-app-pdb
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app: my-app

Pertanyaan Wawancara Kubernetes Lanjutan

Bagian ini membahas pertanyaan wawancara Kubernetes tingkat lanjut, berfokus pada aplikasi stateful, manajemen multiklaster, keamanan, optimalisasi kinerja, dan troubleshooting. Jika Anda melamar posisi senior, pastikan memeriksa bagian ini.

21. Apa itu StatefulSet, dan bagaimana perbedaannya dengan Deployment?

StatefulSet digunakan untuk aplikasi stateful yang membutuhkan identitas jaringan stabil, penyimpanan persisten, dan urutan deployment. Tidak seperti Deployment, StatefulSet memastikan bahwa:

• Pod memiliki identitas jaringan yang stabil dan unik, di mana Pod diberi nama seperti pod-0, pod-1, dan seterusnya.
• Pod dibuat, diperbarui, dan dihapus secara berurutan.
• Setiap Pod mempertahankan penyimpanan persisten di seluruh restart. Penyimpanan persisten didefinisikan sebagai bagian dari YAML StatefulSet.

22. Apa itu service mesh, dan mengapa digunakan di Kubernetes?

Service mesh mengelola komunikasi antar layanan (service-to-service), menyediakan:

• Manajemen trafik (load balancing, canary deployment).
• Keamanan (enkripsi mTLS antar layanan).
• Observabilitas (tracing, metrik, logging)

Semua fitur ini termasuk dalam lapisan infrastruktur, sehingga tidak perlu perubahan kode.

Solusi service mesh Kubernetes populer meliputi: Istio, Linkerd, dan Consul.

23. Bagaimana cara mengamankan klaster Kubernetes?

Ikuti model keamanan 4C untuk mengamankan klaster Kubernetes:

1. Keamanan penyedia cloud: Gunakan peran IAM dan aturan firewall.
2. Keamanan klaster: Aktifkan RBAC, audit log, dan keamanan API server.
3. Keamanan kontainer: Pindai image dan gunakan pengguna non-root.
4. Keamanan kode: Terapkan manajemen secret dan gunakan network policy.

24. Apa itu Taint dan Toleration di Kubernetes?

Taint dan Toleration mengontrol di mana Pod dijalankan:

• Taint: Menandai node untuk menolak Pod.
• Toleration: Mengizinkan Pod untuk mengabaikan Taint tertentu.

Berikut contoh menambahkan taint pada node agar hanya menerima beban kerja tertentu:

kubectl taint nodes node1 key1=value1:NoSchedule

Artinya tidak ada Pod yang dapat dijadwalkan pada node1 sampai Pod tersebut memiliki Toleration yang diperlukan.

Toleration ditambahkan pada bagian PodSpec seperti berikut:

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    env: test
spec:
  containers:
  - name: nginx
    image: nginx
    imagePullPolicy: IfNotPresent
  tolerations:
  - key: "key1"
    operator: "Equal"
    value: “value1”
    effect: "NoSchedule"

Pod tersebut akan diizinkan untuk dijadwalkan pada node1.

25. Apa itu sidecar container Kubernetes, dan bagaimana penggunaannya?

Sidecar container berjalan berdampingan dengan kontainer aplikasi utama di dalam Pod yang sama. Umumnya digunakan untuk:

• Logging dan monitoring (misalnya mengumpulkan log dengan Fluentd).
• Proxy keamanan (misalnya menjalankan Envoy milik Istio untuk service mesh).
• Manajemen konfigurasi (misalnya sinkronisasi pengaturan aplikasi).

Contoh sidecar container untuk pemrosesan log:

apiVersion: v1
kind: Pod
metadata:
  name: app-with-sidecar
spec:
  containers:
    - name: main-app
      image: my-app
      volumeMounts:
        - mountPath: /var/log
          name: shared-logs
    - name: log-collector
      image: fluentd
      volumeMounts:
        - mountPath: /var/log
          name: shared-logs
  volumes:
    - name: shared-logs
      emptyDir: {}

Sidecar container menjalankan Fluentd, yang mengumpulkan log dari kontainer utama melalui volume bersama.

26. Apa itu Native Sidecars (SidecarContainers), dan masalah apa yang mereka selesaikan?

Sebelum Kubernetes v1.28/1.29, sidecar container hanyalah kontainer biasa yang berjalan berdampingan dengan aplikasi Anda. Ini menyebabkan "race condition": jika aplikasi Anda mulai sebelum sidecar (misalnya proxy keamanan atau pengirim log), aplikasi bisa crash atau kehilangan data karena komponen pembantu belum siap.

Native Sidecars menyelesaikan ini dengan memungkinkan Anda mendefinisikan sidecar di dalam bagian initContainers dengan restartPolicy: Always.

• Cara kerja: Kubernetes memperlakukannya sebagai init container, artinya mereka harus berhasil dimulai sebelum aplikasi utama berjalan.
• Keuntungannya: Ini menjamin bahwa proxy keamanan atau logger aktif sepenuhnya sebelum aplikasi Anda menangani satu pun permintaan.

27. Sebutkan tiga penyebab umum error pada Pod dan cara memperbaikinya.

Pod dapat tersangkut pada status Pending, CrashLoopBackOff, atau ImagePullBackOff:

• Pod tersangkut pada Pending: Periksa ketersediaan node dan limit sumber daya. Anda dapat memeriksa event Pod untuk informasi lebih lanjut.
• CrashLoopBackOff: Selidiki log aplikasi dan periksa miskonfigurasi.
• ImagePullBackOff: Pastikan nama image dan kredensial penarikan benar. Sekali lagi, periksa event Pod untuk informasi lebih lanjut.

Anda dapat memeriksa event Pod menggunakan perintah describe:

kubectl describe pod <pod-name>

28. Apa itu mutating admission webhook Kubernetes, dan bagaimana cara kerjanya?

Mutating admission webhook memungkinkan modifikasi secara real-time terhadap objek Kubernetes sebelum diterapkan ke klaster dan dipersistenkan. Webhook ini menjalankan admission controller dinamis di Kubernetes yang mencegat permintaan API sebelum objek dipersistenkan di etcd. Webhook dapat memodifikasi payload permintaan dengan menyisipkan, mengubah, atau menghapus field sebelum permintaan diizinkan untuk diproses.

Umumnya digunakan untuk:

• Menyisipkan sidecar.
• Menetapkan nilai default untuk Pod, Deployment, atau sumber daya lain.
• Menegakkan praktik terbaik (misalnya secara otomatis menetapkan limit sumber daya).
• Menambahkan konfigurasi keamanan (misalnya mewajibkan label untuk pelacakan audit).

29. Bagaimana Anda menerapkan Deployment tanpa downtime di Kubernetes?

Deployment tanpa downtime memastikan bahwa pembaruan tidak mengganggu trafik langsung. Kubernetes mencapainya dengan:

• Rolling update (default, secara bertahap mengganti Pod lama dengan yang baru).
• Canary deployment (menguji dengan sebagian kecil pengguna).
• Blue-green deployment (berpindah antara lingkungan produksi dan uji).

Readiness probe membantu Kubernetes menghindari pengiriman trafik ke Pod yang belum siap.

30. Apa itu Custom Resource Definition (CRD) Kubernetes, dan kapan sebaiknya digunakan?

Custom Resource Definition (CRD) memperluas API Kubernetes, memungkinkan pengguna mendefinisikan dan mengelola sumber daya kustom. CRD digunakan untuk kasus-kasus spesifik di mana API Kubernetes tetap digunakan untuk mengelola sumber daya tersebut, seperti:

• Mengelola aplikasi kustom (misalnya model machine learning).
• Mengaktifkan operator Kubernetes untuk aplikasi self-healing.

Contoh definisi YAML CRD:

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: shirts.stable.example.com
spec:
  group: stable.example.com
  scope: Namespaced
  names:
    plural: shirts
    singular: shirt
    kind: Shirt
  versions:
  - name: v1
    served: true
    storage: true
    schema:
      openAPIV3Schema:
        type: object
        properties:
          spec:
            type: object
            properties:
              color:
                type: string
              size:
                type: string
    selectableFields:
    - jsonPath: .spec.color
    - jsonPath: .spec.size
    additionalPrinterColumns:
    - jsonPath: .spec.color
      name: Color
      type: string
    - jsonPath: .spec.size
      name: Size
      type: string

Anda sekarang dapat, misalnya, mengambil objek shirt menggunakan kubectl:

kubectl get shirts

Pelajari cara memanfaatkan Docker dan Kubernetes untuk alur kerja machine learning dalam tutorial containerization praktis ini.

31. Apa itu operator Kubernetes, dan bagaimana cara kerjanya?

Operator Kubernetes memperluas fungsionalitas Kubernetes dengan mengotomatiskan penyebaran, penskalaan, dan pengelolaan aplikasi yang kompleks. Operator dibangun menggunakan CRD dan controller kustom untuk menangani logika spesifik aplikasi.

Operator bekerja dengan mendefinisikan sumber daya kustom di Kubernetes dan memantau perubahan di klaster untuk mengotomatiskan tugas tertentu.

Berikut komponen kunci dari sebuah operator:

• Custom Resource Definition (CRD): Mendefinisikan sumber daya API Kubernetes baru.
• Controller kustom: Memantau CRD dan menerapkan logika otomatis berdasarkan desired state.
• Reconciliation loop: Secara berkelanjutan memastikan state aplikasi sesuai dengan state yang diharapkan.

Pertanyaan Wawancara Kubernetes untuk Administrator

Administrator Kubernetes memelihara, mengamankan, dan mengoptimalkan klaster untuk beban kerja produksi. Bagian ini mencakup pertanyaan wawancara Kubernetes yang berfokus pada manajemen klaster.

32. Bagaimana Anda melakukan backup dan restore klaster etcd di Kubernetes?

Etcd adalah penyimpanan key-value yang menampung seluruh state klaster. Backup rutin sangat penting untuk menghindari kehilangan data.

Anda dapat membuat backup menggunakan perintah di bawah ini:

ETCDCTL_API=3 etcdctl --endpoints=https://127.0.0.1:2379 \
  --cacert=<trusted-ca-file> --cert=<cert-file> --key=<key-file> \
  snapshot save <backup-file-location>

Jika Anda ingin melakukan restore dari backup, jalankan:

etcdutl --data-dir <data-dir-location> snapshot restore snapshot.db

33. Bagaimana Anda meng-upgrade klaster Kubernetes dengan aman?

Upgrade klaster Kubernetes adalah proses multilangkah yang membutuhkan downtime minimal dan menjaga stabilitas klaster. Administrator harus mengikuti pendekatan terstruktur untuk mencegah masalah selama upgrade:

1. Drain dan backup etcd sebelum upgrade untuk memastikan Anda dapat melakukan restore jika upgrade gagal.
2. Upgrade control plane node.
3. Upgrade kubelet dan kubectl pada node control plane.
4. Upgrade worker node satu per satu. Sebelum upgrade, setiap worker node harus di-drain untuk mencegah gangguan beban kerja.
5. Upgrade add-on klaster (misalnya Ingress controller, alat monitoring, …).

34. Bagaimana Anda memantau klaster Kubernetes?

Administrator Kubernetes harus memantau CPU, memori, disk, jaringan, dan kesehatan aplikasi. Alat berikut direkomendasikan untuk tugas-tugas ini:

• Prometheus + Grafana: Mengumpulkan dan memvisualisasikan metrik klaster. Buat alert real-time untuk mendapatkan notifikasi jika terjadi masalah.
• Loki + Fluentd: Mengumpulkan dan menganalisis log.
• Kubernetes dashboard: Pemantauan klaster berbasis UI.
• Jaeger/OpenTelemetry: Tracing terdistribusi.

35. Bagaimana Anda mengamankan klaster Kubernetes?

Keamanan adalah aspek kunci, dan setiap administrator harus mengikuti praktik terbaik untuk mengamankan klaster Kubernetes:

• Aktifkan RBAC: Batasi akses pengguna menggunakan Role dan RoleBinding.
• Pod security admission: Gunakan admission controller untuk menegakkan standar keamanan Pod.
• Terapkan NetworkPolicy: Batasi komunikasi antarpod, karena secara default semua Pod dapat saling berkomunikasi.
• Rutin rotasi token API dan sertifikat.
• Gunakan manajemen secret: Gunakan alat seperti Vault, AWS Secrets Manager, dll.

Pelajari bagaimana Kubernetes diimplementasikan di cloud melalui panduan orkestrasi kontainer menggunakan AWS Elastic Kubernetes Service (EKS) ini.

36. Bagaimana Anda menyiapkan logging Kubernetes?

Logging terpusat diperlukan untuk debugging dan audit. Dua opsi tumpukan logging yang berbeda:

• Loki + Fluentd + Grafana (Ringan dan cepat).
• ELK Stack (Elastic, Logstash, Kibana) (Skalabel dan kelas enterprise).

37. Bagaimana Anda menerapkan high availability di Kubernetes?

High availability penting untuk menghindari downtime aplikasi yang berjalan di klaster Kubernetes Anda. Anda dapat memastikan high availability dengan:

• Menggunakan beberapa control plane node. Beberapa API server mencegah downtime jika salah satunya gagal.
• Mengaktifkan cluster autoscaler. Ini secara otomatis menambah/menghapus node berdasarkan permintaan.

38. Bagaimana Anda menerapkan multi-tenancy klaster Kubernetes?

Multi-tenancy sangat penting saat Anda menyiapkan Kubernetes untuk perusahaan Anda. Ini memungkinkan banyak tim atau aplikasi berbagi klaster Kubernetes dengan aman tanpa saling mengganggu.

Ada dua jenis multi-tenancy:

1. Soft multi-tenancy: Menggunakan Namespace, RBAC, dan NetworkPolicy untuk isolasi pada tingkat namespace.
2. Hard multi-tenancy: Menggunakan virtual cluster atau control plane terpisah untuk mengisolasi klaster fisik (misalnya KCP).

39. Bagaimana Anda mengenkripsi secret Kubernetes di etcd?

Etcd menyimpan seluruh state klaster, artinya informasi kritis disimpan di sana.

Secara default, Kubernetes menyimpan secret tanpa enkripsi di etcd, sehingga rentan terhadap kompromi. Karena itu, penting untuk mengaktifkan enkripsi secret saat REST sehingga secret disimpan dan dienkripsi.

Langkah pertama, buat berkas konfigurasi enkripsi dan simpan kunci enkripsi/dekripsi di berkas tersebut:

apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
  - resources:
      - secrets
    providers:
      - aescbc:
          keys:
            - name: key1
              secret: <BASE64_ENCODED_SECRET>
      - identity: {}

Konfigurasi di atas menentukan bahwa Kubernetes akan menggunakan penyedia aescbc untuk mengenkripsi sumber daya Secret, dengan fallback ke identity untuk data yang tidak terenkripsi.

Selanjutnya, Anda perlu menyesuaikan berkas konfigurasi kube-apiserver, biasanya berada di /etc/kubernetes/manifests/kube-apiserver.yaml pada control plane node, dan sertakan flag -- encryption-provider-config yang mengarah ke berkas konfigurasi enkripsi yang telah Anda buat:

command:
  - kube-apiserver
  ...
  - --encryption-provider-config=/path/to/encryption-config.yaml

Simpan perubahan dan mulai ulang kube-apiserver untuk menerapkan konfigurasi baru.

40. Bagaimana Anda mengelola resource quota Kubernetes di lingkungan multi-penyewa?

Resource quota mencegah satu penyewa (namespace) mengonsumsi sumber daya klaster secara berlebihan, sehingga mengganggu penyewa lain.

Anda dapat mendefinisikan ResourceQuota untuk namespace guna memberikan sejumlah sumber daya tertentu pada namespace tersebut. Pengguna namespace itu kemudian dapat membuat sumber daya yang mengonsumsi hingga batas yang ditentukan dalam ResourceQuota namespace tersebut.

Contoh definisi YAML ResourceQuota:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: namespace-quota
  namespace: team-a
spec:
  hard:
    requests.cpu: "4"
    requests.memory: "8Gi"
    limits.cpu: "8"
    limits.memory: "16Gi"
    pods: "20"

Anda dapat memeriksa ResourceQuota suatu namespace menggunakan:

kubectl describe resourcequota namespace-quota -n team-a

41. Apa itu CoreDNS? Bagaimana cara mengonfigurasi dan menggunakannya?

CoreDNS adalah penyedia DNS default untuk klaster Kubernetes. CoreDNS menyediakan service discovery dan memungkinkan Pod berkomunikasi menggunakan nama DNS internal alih-alih alamat IP.

Fitur CoreDNS:

• Menangani resolusi DNS internal (my-service.default.svc.cluster.local).
• Mendukung konfigurasi DNS kustom.
• Melakukan load-balance kueri DNS di beberapa Pod.
• Mengizinkan caching untuk kinerja yang lebih baik.

Anda dapat mengonfigurasi CoreDNS menggunakan ConfigMap yang disimpan di namespace kube-system. Anda dapat melihat pengaturan saat ini menggunakan:

kubectl get configmap coredns -n kube-system -o yaml

Cukup perbarui ConfigMap tersebut dan terapkan perubahannya untuk menyesuaikan konfigurasi CoreDNS.

Pertanyaan Wawancara Kubernetes Berbasis Skenario dan Pemecahan Masalah

Engineer secara rutin menghadapi tantangan skalabilitas, jaringan, keamanan, kinerja, dan troubleshooting yang kompleks di lingkungan Kubernetes dunia nyata, dan para pewawancara mengetahuinya. Bagian ini menyajikan pertanyaan wawancara berbasis skenario yang menguji kemampuan Anda memecahkan masalah Kubernetes secara praktis.

42. Melakukan debug pada aplikasi Kubernetes yang lambat

“Tim Anda melaporkan bahwa aplikasi yang berjalan di Kubernetes menjadi lambat, dan pengguna mengalami waktu respons yang tinggi. Bagaimana Anda menyelesaikan masalah ini?”

Anda dapat mendekati masalah ini dengan langkah-langkah berikut:

1. Periksa utilisasi sumber daya Pod. Tambah sumber daya jika sudah pada batasnya.

kubectl top pods --sort-by=cpu
kubectl top pods --sort-by=memory

2. Lakukan describe pada Pod yang lambat untuk mendapatkan informasi lebih lanjut. Cari throttling sumber daya, jumlah restart, atau kegagalan liveness probe.

kubectl describe pod <pod-name>

3. Periksa log kontainer untuk error. Cari timeout, error, atau kegagalan koneksi.

kubectl logs <pod-name>

4. Uji latensi jaringan, karena dapat memperlambat aplikasi.

kubectl exec -it <pod-name> -- ping my-database
kubectl exec -it <pod-name> -- curl http://my-service

5. Verifikasi kesehatan node Kubernetes dan periksa kehabisan sumber daya pada node.

kubectl get nodes
kubectl describe node <node-name>

43. Server web Nginx berjalan, tetapi URL yang diekspos gagal terhubung

“Anda menyebarkan server web Nginx di Kubernetes, dan Pod berjalan dengan baik, tetapi aplikasi tidak dapat diakses melalui URL yang diekspos. Apa yang dapat Anda lakukan?”

Langkah untuk menangani masalah di atas:

1. Verifikasi bahwa Pod Nginx berjalan dan sehat.

kubectl get pods -o wide
kubectl describe pod nginx-web

2. Periksa Service dan pemetaan port. Pastikan port yang tepat diekspos dan sesuai dengan containerPort Pod. Periksa bahwa Service menemukan Pod yang benar.

kubectl describe service nginx-service

3. Periksa network policy. Jika network policy memblokir trafik masuk, Service tidak akan dapat diakses.

kubectl get networkpolicies
kubectl describe networkpolicy <policy-name>

4. Verifikasi konfigurasi Ingress dan DNS eksternal.

kubectl describe ingress nginx-ingress

44. Deployment Kubernetes gagal setelah upgrade

“Anda menyebarkan versi baru aplikasi Anda, tetapi gagal mulai, menyebabkan downtime bagi pengguna. Bagaimana Anda memperbaiki masalah ini?”

Pendekatan untuk mengatasi masalah:

1. Rollback ke versi yang sebelumnya bekerja.

kubectl rollout undo deployment my-app

2. Periksa riwayat Deployment dan identifikasi perubahan apa yang ada di versi baru.

kubectl rollout history deployment my-app

3. Periksa log Pod baru untuk mencari error.

kubectl logs -l app=my-app

4. Periksa readiness dan liveness probe.

5. Verifikasi masalah penarikan image. Terkadang image baru salah atau tidak tersedia.

45. Aplikasi tidak dapat terhubung ke database eksternal

“Sebuah microservice yang berjalan di Kubernetes gagal terhubung ke database eksternal, yang dihosting di luar klaster. Bagaimana Anda memperbaiki masalah ini?”

Langkah untuk menangani masalah:

1. Verifikasi konektivitas eksternal dari dalam Pod. Periksa apakah database dapat dijangkau dari jaringan Kubernetes.

kubectl exec -it <pod-name> -- curl http://my-database.example.com:5432

2. Periksa resolusi DNS di dalam Pod. Jika gagal, kemungkinan konfigurasi CoreDNS salah.

kubectl exec -it <pod-name> -- nslookup my-database.example.com

3. Periksa apakah ada network policy yang memblokir akses eksternal, karena kebijakan tersebut dapat mencegah trafik keluar.

kubectl get networkpolicies
kubectl describe networkpolicy <policy-name>

46. Sumber daya klaster habis, menyebabkan Pod baru tetap berstatus pending

“Pod baru tetap pada status Pending. Setelah ditelusuri, terlihat pesan “0/3 nodes are available: insufficient CPU and memory”. Bagaimana Anda melakukan debug dan menyelesaikan masalah tersebut?”

Langkah untuk menangani masalah:

1. Periksa ketersediaan sumber daya klaster. Cari penggunaan CPU/memori tinggi yang mencegah penjadwalan.

kubectl describe node <node-name>
kubectl top nodes

2. Periksa Pod mana yang mengonsumsi sumber daya paling banyak. Tetapkan request dan limit untuk Pod agar tidak berlebihan. Anda juga dapat menegakkannya untuk semua namespace di klaster.

kubectl top pods --all-namespaces

3. Skala turun beban kerja non-esensial untuk membebaskan sumber daya.

kubectl scale deployment <deployment-name> --replicas=0

4. Tambah node yang tersedia untuk meningkatkan sumber daya klaster. Anda juga dapat menambah lebih banyak node pada cluster autoscaler jika digunakan.

Tips Mempersiapkan Wawancara Kubernetes

Berdasarkan pengalaman saya sendiri mengikuti wawancara Kubernetes, saya belajar bahwa kesuksesan membutuhkan lebih dari sekadar menghafal konsep. Anda perlu menerapkan pengetahuan dalam skenario nyata, melakukan troubleshooting secara efisien, dan menjelaskan solusi Anda dengan jelas.

Jika Anda ingin sukses dalam wawancara Kubernetes, ikuti tips di bawah ini:

1. Kuasai konsep inti Kubernetes. Pastikan Anda memahami Pod, Deployment, Service, Persistent Volume, ConfigMap, Secret, dan lain-lain.
2. Dapatkan pengalaman langsung dengan Kubernetes. Saat mempersiapkan wawancara, saya mendapati bahwa menyiapkan klaster Minikube sendiri dan menyebarkan microservice sangat membantu memperkuat pemahaman saya. Anda juga dapat menggunakan layanan Kubernetes terkelola dari penyedia cloud untuk berlatih dalam skala besar.
3. Pelajari cara melakukan debug masalah Kubernetes, karena troubleshooting merupakan bagian signifikan dari bekerja dengan Kubernetes di dunia nyata. Anda mungkin akan menghabiskan sebagian besar waktu untuk troubleshooting aplikasi di tempat kerja.
• Masalah umum yang terjadi termasuk Pod yang tersangkut, kegagalan jaringan, persistent volume yang tidak ter-mount dengan benar, dan kegagalan node.
4. Pahami jaringan dan load balancing Kubernetes. Fokus pada bagaimana jaringan diimplementasikan, bagaimana Pod berkomunikasi, jenis Service yang ada, dan cara mengekspos aplikasi.
5. Ketahui cara melakukan penskalaan dan mengoptimalkan beban kerja Kubernetes. Pewawancara sering menanyakan tentang strategi penskalaan dan optimasi biaya. Kuasai HPA, cluster autoscaler, request, dan limit sumber daya.
6. Pahami praktik terbaik keamanan Kubernetes. Kenali RBAC, konteks keamanan Pod, network policy, dan manajemen secret.
7. Pelajari arsitektur dan internal Kubernetes. Pahami komponen control plane serta bagaimana kubelet dan container runtime berinteraksi.

Dengan menggabungkan pengetahuan teoretis dan praktik langsung, serta belajar dari troubleshooting dunia nyata, Anda akan menguasai wawancara Kubernetes apa pun!

Kesimpulan

Kubernetes adalah sistem orkestrasi kontainer yang kuat namun kompleks. Mengikuti wawancara untuk peran Kubernetes memerlukan pemahaman mendalam tentang teori dan pemecahan masalah dunia nyata. Baik Anda seorang engineer junior yang mencari pekerjaan pertama atau engineer senior yang menargetkan peran lebih lanjut, persiapan selalu menjadi kunci.

Saya sangat menekankan betapa pentingnya praktik. Praktik membantu Anda menemukan masalah pada aplikasi lebih cepat dan meningkatkan kepercayaan diri Anda.

Jika Anda ingin memperkuat fundamental, saya sangat merekomendasikan mempelajari kursus seperti Containerization and Virtualization Concepts untuk membangun fondasi yang kuat, dilanjutkan dengan Introduction to Kubernetes untuk mendapatkan pengalaman praktis dengan Kubernetes. Setelah siap, Anda dapat melihat sertifikasi Kubernetes untuk memamerkan keterampilan Anda.

Semoga sukses dalam wawancara Anda!