AdityaDees

mengenal replication controller - Replication Controller adalah sebuah fitur yang memastikan pod agar selalu berjalan. Ketika salah satu node mati karena hal tertentu, Replication Controller akan secara otomatis membuat ulang pod yang berada di node mati tersebut kedalam node lain.

Apapun kesalahannya, fitur ini akan secara pintar me-manage segala kekurangan dari pod tersebut dan memastikan bahwa jumlah dan fungsinya sudah sesuai.

Membuat Replication Controller

Template:

apiVersion: v1
kind: ReplicationController
metadata:
  name: nama-replication-controller
spec:
  replicas: jumlah-replica
  selector:
    label-key1: label-value1
  template:
    metadata:
      name: nama-pod
      labels:
        label-key1: label-value1
    spec:
      containers:
        - name: container-name
          image: image-name
          ports:
            - containerPort: 80

Contoh:

nginx-rc.yaml

apiVersion: v1
kind: ReplicationController
metadata:
  name: nginx-rc
spec:
  replicas: 3
  selector:
    app: nginx
  template:
    metadata:
      name: nginx
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx
          ports:
            - containerPort: 80

Pada spec.replicas, saya masukan value 3. Yang artinya saya akan menjaga agar nginx selalu berjalan di 3 pod. Meskipun pod dihapus, replication controller akan secara otomatis generate pod baru.

$ kubectl get replicationcontroller
$ kubectl get pod

$ kubectl delete replicationcontroller nginx-rc

memahami probe - Setelah belajar Namespace, selanjutnya kita akan belajar Probe. Probe adalah sistem pengecekan pada kubernetes yang berfungsi untuk me-restart pod jika ada kesalahan. Probe memiliki 2 jenis pengecekan atau fitur utama yaitu Liveness, Readiness, dan Startup Probe.

1. Liveness, yaitu pengecekan ketika ada error di pod, maka pod akan otamatis di-restart.
2. Readiness, yaitu pengecekan ketika ada error di pod, maka semua traffic akan di-blok.
3. Startup, yaitu pengecekan yang terjadi hanya di awal up pod. Tujuannya adalah memastikan pod berjalan dengan baik dan siap menerima traffic.

Mekanisme Pengecekan Probe

Ada 3 cara melakukan pengecekan probe berdasarkan jenis aplikasi dalam pod yang digunakan, yaitu:

1. HTTP get, untuk aplikasi web
2. TCP socket, untuk aplikasi socket server/web
3. Command Exec, untuk aplikasi general

Konfigurasi Pengecekan

1. initialDelaySeconds, yaitu delay di awal ketika pod baru dijalankan.
2. periodSeconds, seberapa sering pengecekan dilakukan (setiap berapa detik).
3. timeoutSeconds, seberapa lama respon yang diterima. Jika lebih, maka dianggap error.
4. successThreshold, seberapa banyak pengecekan agar pod bisa dianggap sehat. 
5. failureThreshold, seberapa banyak pengecekan agar pod dianggap error.

Membuat Pod Dengan Probe Di Dalamnya

apiVersion: v1
kind: Pod
metadata:
  name: pod-name
  labels:
    label-key1: label-value1
  annotations:
    annotation-key1: annotation-value
spec:
  containers:
    - name: container-name
      image: image-name
      ports:
        - containerPort: 80
      livenessProbe:
        httpGet:
          path: /health
          port: 80
        initialDelaySeconds: 0
        periodSeconds: 10
        timeoutSeconds: 1
        successThreshold: 1
        failureThreshold: 3
      readinessProbe:
        httpGet:
          path: /
          port: 80
        initialDelaySeconds: 0
        periodSeconds: 10
        timeoutSeconds: 1
        successThreshold: 1
        failureThreshold: 3
      startupProbe:
        httpGet:
          path: / 
          port: 80
        initialDelaySeconds: 0
        periodSeconds: 10
        timeoutSeconds: 1
        successThreshold: 1
        failureThreshold: 3

Di dalam konfigurasi probe, kita bisa menambahkan liveness, readiness, dan startup secara bersamaan, atau salah satu sesuai kebutuhan.

Kita akan membuat pod nginx dengan menerapkan liveness probe. Karena nginx dapat diakses melalui http, kita akan menggunakan metode pengecekan httpGet.

pod-nginx.yaml

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    label-key1: label-value1
  annotations:
    annotation-key1: annotation-value
spec:
  containers:
    - name: container-name
      image: image-name
      ports:
        - containerPort: 80
      livenessProbe:
        httpGet:
          path: /
          port: 80
        initialDelaySeconds: 5
        periodSeconds: 5
        timeoutSeconds: 1
        successThreshold: 1
        failureThreshold: 3

$ kubectl create -f pod-nginx.yaml

Selanjutnya, kita akan mencoba mematikan lalu menyalakan kembali minikube agar pod yang kita buat error.

$ minikube stop

$ minikube start

Lalu kita cek pod yang kita buat tadi.

$ kubectl describe pod nginx

Oke, itulah penjelasan mengenai Prob. Selanjutnya kita akan belajar tentang Replication Controller.

mengenal namespace di kubernetes - Namespace digunakan untuk mengelompokan seluruh aplikasi dalam kubernetes. Namun namespace berbeda dengan Label. Ketika kita membuat pod dan service lain, sebenarnya kita membuatnya di namespace bernama default yang dibuat otomatis oleh kubernetes. Namun kita bisa membuat namespace baru sesuai keinginan kita. Lalu mengapa kita harus membuat namespace?

Namespace sangat berguna ketika kita memiliki service yang sudah sangat banyak. Biasanya, namespace dinamakan sesuai nama tenant, team, atau environment yang memudahkan kita dalam memisah service. Service dengan nama yang sama boleh berjalan asalkan di namespace yang bereda. Walau begitu, service masih tetap bisa berkomunikasi satu sama lain.

Melihat List Namespace

$ kubectl get namespace

$ kubectl get pod -n <nama-namespace>

Contoh:

$ kubectl get pod -n default

Membuat Namespace

team1-namespace.yaml

apiVersion: v1
kind: Namespace
metadata:
  name: nama-namespace

Selanjutnya, jalankan command ini:

$ kubectl create -f team1-namespace.yaml

Membuat Pod di Dalam Namespace

pod-nginx.yaml

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  annotations:
    foo: bar
    test: bla bla bla
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
      - containerPort: 80

$ kubectl create -f pod-nginx.yaml --namespace team1

Menghapus Namespace dan Seluruh Pod Di Dalamnya

$ kubectl delete namespace team1

Oke, itulah sedikt pemahaman soal Namsepace di kubernetes. Di artikel selanjutnya, kita akan belajar tentang Probe.

memahami annotation di kubernetes - Sebelumnya kit telah belajar tentang, Belajar Kubernetes 2: Memahami Label. Pada dasarnya, annotation sama seperti label. Tetapi, annotation hanya berlaku sebagai informasi tambahan pada sebuah service yang tidak dapat dijadikan filter. Value annotation juga deskriptif yang bisa memuat kalimat sampai 256kb.

Membuat Annotation

Kita bisa menyisipkan annotation pada file yaml konfigurasi pod dibawah ini:

pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: nama-pod
  annotations:
      ....
spec:
  containers:
      - ....   

Contoh:

pod-nginx-.yaml

apiVersion: v1
kind: Pod
metadata:
  name: nginx-annotation
  annotations:
    foo: bar
    test: bla bla bla
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
      - containerPort: 80

Setelah itu, buat pod nya.

$ kubectl create -f pod-nginx.yaml

$ kubectl describe pod nginx

Menambah Annotation Pada Pod Yang Sedang Berjalan

$ kubectl annotate pod <nama-pod> key=value
$ kubectl annotate pod <nama-pod> key=value --overwrite

Oke, itulah sedikit penjelasan tentang annotation. Sampai jumpa di pembelajaran selanjutnya, Belajar Kubernetes 5: Namespace.

memahami label di kubernetes - Label adalah kata yang digunakan sebagai tanda tertentu untuk sebuah pod. Label dapat berfungsi untuk memberi informasi tambahan pada pod, atau mengelompokan pod berdasarkan pembagian label nya. Tidak hanya pod, label bisa digunakan untuk seluruh elemen kubernetes seperti Replicaset, Replication Controller, dan lain-lain.

Pada dasarnya, label mengorganisir setiap service pada kubernetes, yang mana nantinya bisa memudahkan servis lain untuk memilih beberapa servis sesuai label yang telah dibuat.

Kita telah berhasil membuat Pod di artikel sebelumnya, Belajar Kubernetes 2: Memahami Pod. Selanjutnya, kita akan coba menambah label pada konfigurasi pod yang sama.

Membuat Label

Kita bisa menyisipkan label pada file yaml konfigurasi pod dibawah ini:

pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: nama-pod
  labels:
      ....
spec:
  containers:
      - ....   

Contoh:

pod-nginx-.yaml

apiVersion: v1
kind: Pod
metadata:
  name: nginx-label
  labels:
    team: developer-one
    version: 0.0.1
    environment: production
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
      - containerPort: 80

Setelah itu, buat pod nya.

$ kubectl create -f pod-nginx.yaml

$ kubectl get pods --show-labels

Menampilkan Pod Berdasarkan Label

Berdasarkan key label.

$ kubectl get pods -l key

Berdasarkan key dan value label.

$ kubectl get pods -l key=value

Pengecualian key.

$ kubectl get pods -l '!key'

Pengecualian key=value.

$ kubectl get pods -l key!=value

Kondisioal 'berada di dalam'.

$ kubectl get pods -l 'key in (value1, value2)'

Kondisional 'tidak berada di dalam'.

$ kubectl get pods -l 'key notin (value1, value2)'

push pull docker image dari google container registry - Artikel ini akan membahas bagaimana cara berinteraksi langsung dengan container registry dari google cloud melalui docker.

Inisiasi Google Cloud SDK

Pertama, pastikan device kalian sudah terinstall google cloud sdk dan ter-init dengan perintah gcloud. Jika belum, jalankan perintah berikut ini.

$ gcloud init

Lakukan inisiasi sesuai project yang akan di-manage.

Autentikasi

Selanjutnya, kita akan membuat perintah docker terhubung dengan autentikasi dari gcloud. Jalankan perintah berikut ini.

$ gcloud auth configure-docker

Tekan Y jika ada pertanyaan konfirmasi.

Jika berhasil, akan terbuat secara otomatis file ~/.docker/config.json sebagai file konfigurasi docker.

List Seluruh Container Images di Registry

$ gcloud container images list

Pull Image Dari Container Images di Registry

$ docker pull HOSTNAME/PROJECT-ID/IMAGE:TAG

Contoh:

$ docker pull gcr.io/myproject/nginx:latest

Push Image ke Google Container Registry

Untuk push image ke gcr, pastikan kalian telah build image yang ingin kalian push menggunakan docker build seperti biasa.

Setelah itu, copy image nya dengan perintah berikut.

$ docker image tag myimage:tag HOSTNAME/PROJECT-ID/IMAGE:TAG

Contoh:

$ docker image tag nginxlocal:latest gcr.io/myproject/nginx:latest

Setelah itu, jika kita menjalankan docker images, akan ada image baru bernama gcr.io/myproject/nginx:latest.

Selanjutnya, push image tersebut dengan perintah berikut.

$ docker image push --all-tags HOSTNAME/PROJECT-ID/IMAGE

Contoh:

$ docker image push --all-tags gcr.io/myproject/nginx

Maka seluruh tag dari image gcr.io/myproject/nginx lokal akan ter-push otomatis ke gcr.io/myproject/nginx google cloud.

memahami pod dalam kubernetes - Setelah berhasil menginstall dan menjalankan minikube, selanjutnya saya akan membahas tentang Pod. Pod adalah unit terkecil dari kubernetes yang berfungsi sebagai container manager, yaitu ruang penyimpanan untuk mengelompokan satu atau lebih container (misalnya docker container) yang bisa dipakai bersamaan.

Ilustrasi Pod dan container di dalamnya

Pod memudahkan kita dalam proses scaling aplikasi. Contohnya adalah ketika kita ingin scale service A yang membutuhkan environment terbaru atau versi scale dari service B. Kita harus scaling kedua service tersebut secara bersamaan, namun hal itu akan membuat aplikasi down. Dengan pod, kita bisa menggabungkan service A dan B kedalam satu Pod, yang kemudian kita bisa dengan mudah scale service B tanpa ada gangguan.

Membuat Pod

Untuk membuat pod, kita harus memiliki file yaml sebagai konfigurasi pod. Berikut ini adalah template nya.

apiVersion: v1
kind: Pod
metadata:
  name: nama-pod
spec:
  containers:
  - name: nama-container-1
    image: image-container-1
    ports:
      - containerPort: port-container-1
  - name: nama-container-2
    image: image-container-2
    ports:
      - containerPort: port-container-2
  - name: nama-container-3
    image: image-container-3
    ports:
      - containerPort: port-container-3

Sebagai contoh praktek, kita akan mencoba membuat pod yang berisi 1 container. Kita akan menggunakan nginx sebagai service / image container. Maka, berikut ini adalah file konfigurasinya.

pod-nginx.yaml

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
      - containerPort: 80

Untuk menjalankan perintah membuat pod, buka terminal di lokasi file pod-nginx.yaml berada. Kemudian jalankan perintah berikut.

$ kubectl create -f pod-nginx.yaml

Melihat List Pod Yang Sedang Berjalan

1. List ringkasan Pod

$ kubectl get pod

2. List Pod secara lebih detail

$ kubectl get pod -o wide

$ kubectl describe pod <nama-pod>

$ kubectl delete pod <nama-pod>

Untuk mengakses pod, kita harus melakukan port-forwarding dari ip pod ke ip localhost.

$ kubectl port-forward <nama-pod> <port-lokal>:<port-pod>

menjalankan kubernetes di lokal - Untuk menjalankan kubernetes, diperlukan beberapa server untuk menjadikannya node. Namun sebagai pembelajaran, kita bisa membuat kubernetes di lokal dan membagi hardisk kita sendiri untuk dijalankan sebagai node. Yaitu dengan menggunakan minikube.

Minikube adalah program perangkat lunak yang memungkinkan kita untuk menjalankan kubernetes di dalam perangkat/komputer pribadi dengan satu node. Untuk menginstall dan menjalankan minikube, ikuti langkah berikut ini.

Requirement sebelum memulai.

1. Kubectl. Install disini.

2. Docker. Install disini.

Menginstall Minikube

Linux

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

Mac

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-darwin-amd64
sudo install minikube-darwin-amd64 /usr/local/bin/minikube

Windows

1. Download minikube untuk windows disini.

2. Tambah binary ke path. Jalankan Powershell sebagai Administrator.

$oldPath = [Environment]::GetEnvironmentVariable('Path', [EnvironmentVariableTarget]::Machine)
if ($oldPath.Split(';') -inotcontains 'C:\minikube'){ `
  [Environment]::SetEnvironmentVariable('Path', $('{0};C:\minikube' -f $oldPath), [EnvironmentVariableTarget]::Machine) `
}

Menjalankan Cluster Minikube

Buka terminal sebagai Admin (tetapi bukan root).

$ minikube start

Menghentikan Cluster Minikube

$ minikube stop

Tambahan

Kita juga bisa mengoperasikan minikube melaluli Lens. Salah satu GUI untuk kubernetes.