Deployment

Versi Bahasa Indonesia. Baca dalam Bahasa Inggris

Deployment mengelola sekumpulan Pod untuk menjalankan beban kerja aplikasi, biasanya aplikasi yang tidak menyimpan state.

Membuat Aplikasi Sederhana

Pertama, mari kita buat aplikasi golang sederhana dengan mengikuti langkah-langkah di bawah ini:

• Buat folder baru bernama simple-go.
• Inisialisasi Go Module menggunakan go mod init.
• Buat file main.go.
• Struktur folder Anda akan terlihat seperti ini:

simple-go
├── go.mod
└── main.go

• Kemudian mari kita buat server http sederhana yang akan mengembalikan respons json seperti {"message":"success"}.
• Anda dapat menyalin kode berikut:

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)

type Response struct {
    Message string `json:"message"`
}

func main() {
    srv := http.NewServeMux()
    srv.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        res := Response{
            Message: "Success",
        }

        err := json.NewEncoder(w).Encode(res)
        if err != nil {
            log.Fatal(err)
        }
    })

    fmt.Println("Server is running on port 8080...")
    err := http.ListenAndServe(":8080", srv)
    if err != nil {
        log.Fatal(err)
    }
}

• Mari kita coba jalankan kode dengan perintah go run main.go.
• Anda akan melihat output ini di terminal:

Server is running on port 8080...

• Mari kita coba akses menggunakan curl ke localhost port 8080 dan akan mengembalikan respons seperti ini:

➜ curl http://127.0.0.1:8080
{"message":"Success"}

Membangun Docker Image

Setelah aplikasi sederhana berjalan dengan baik, langkah selanjutnya adalah membangun docker image untuk aplikasi yang baru kita buat. Buat file bernama Dockerfile di folder root dan untuk saat ini Anda dapat menyalin konfigurasi di bawah ini:

# Builder stage
FROM golang:1.22 AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o server .

# Runtime image stage
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/server .
CMD [ "./server" ]

Untuk membangun image sehingga tersedia di Minikube, kita perlu mengikuti langkah-langkah berikut:

• Pertama, beralih ke Minikube's Docker Daemon menggunakan perintah eval $(minikube docker-env).
• Kemudian kita dapat membangun docker image dengan tag simple-go seperti ini:

docker build --tag simple-go .

• Kita dapat memeriksa menggunakan perintah docker images dan image simple-go akan ada dalam daftar:

➜ docker images
REPOSITORY                                TAG        IMAGE ID       CREATED          SIZE
simple-go                                 latest     d47dfe963439   12 minutes ago   15.1MB
registry.k8s.io/kube-apiserver            v1.31.0    cd0f0ae0ec9e   5 months ago     91.5MB
registry.k8s.io/kube-scheduler            v1.31.0    fbbbd428abb4   5 months ago     66MB
registry.k8s.io/kube-controller-manager   v1.31.0    fcb0683e6bdb   5 months ago     85.9MB
registry.k8s.io/kube-proxy                v1.31.0    71d55d66fd4e   5 months ago     94.7MB
registry.k8s.io/etcd                      3.5.15-0   27e3830e1402   6 months ago     139MB
registry.k8s.io/pause                     3.10       afb61768ce38   8 months ago     514kB
registry.k8s.io/coredns/coredns           v1.11.1    2437cf762177   17 months ago    57.4MB
kubernetesui/dashboard                    <none>     20b332c9a70d   2 years ago      244MB
kubernetesui/metrics-scraper              <none>     a422e0e98235   2 years ago      42.3MB
gcr.io/k8s-minikube/storage-provisioner   v5         ba04bb24b957   3 years ago      29MB

Membuat Deployment

Dengan image yang sudah siap di Minikube docker daemon, kita dapat melanjutkan membuat konfigurasi deployment Kubernetes. Beri nama file deployment.yaml dan Anda dapat menyalin konfigurasi di bawah ini, lalu kita akan memecahnya bagian demi bagian.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: simple-go
  labels:
    app: simple-go
spec:
  replicas: 3
  selector:
    matchLabels:
      app: simple-go
  template:
    metadata:
      labels:
        app: simple-go
    spec:
      containers:
      - name: server
        image: simple-go:latest
        imagePullPolicy: Never
        ports:
        - containerPort: 8080

Struktur Umum

apiVersion: apps/v1
kind: Deployment

• apiVersion: apps/v1: Menentukan versi API dari resource Deployment. apps/v1 adalah versi API yang paling umum digunakan untuk Deployment di Kubernetes.
• kind: Deployment: Mendefinisikan jenis resource Kubernetes yang dibuat. Di sini, ini adalah Deployment.

Bagian Metadata

metadata:
  name: simple-go
  labels:
    app: simple-go

• metadata:: Berisi metadata tentang resource.
• name: simple-go: Nama Deployment. Ini harus unik dalam namespace.
• labels:: Pasangan key-value yang digunakan untuk menandai Deployment. Label ini berguna untuk mengidentifikasi dan mengelompokkan resource.
  • app: simple-go: Label yang menunjukkan Deployment ini terkait dengan aplikasi simple-go.

Bagian Spec

spec:
  replicas: 3
  selector:
    matchLabels:
      app: simple-go

• spec:: Mendefinisikan status yang diinginkan untuk Deployment.
• replicas: 3: Menentukan jumlah replika Pod yang harus dipertahankan. Kubernetes akan memastikan tiga Pod berjalan setiap saat.
• selector:: Mendefinisikan bagaimana Kubernetes mengidentifikasi Pod yang dikelola oleh Deployment ini.
  • matchLabels:: Memfilter Pod dengan mencocokkan label mereka.
    • app: simple-go: Ini mencocokkan Pod yang memiliki label app: simple-go.

Bagian Template

template:
  metadata:
    labels:
      app: simple-go

• template:: Mendeskripsikan Pod yang akan dibuat dan dikelola oleh Deployment.
• metadata:: Metadata khusus untuk Pod.
  • labels:: Label yang diberikan ke setiap Pod yang dibuat oleh Deployment ini.
    • app: simple-go: Memastikan Pod memiliki label app: simple-go, yang cocok dengan selector.

Bagian Pod Spec

  spec:
    containers:
    - name: simple-go
      image: go-configurable-port
      imagePullPolicy: Never
      ports:
      - containerPort: 8080

• spec:: Mendefinisikan konfigurasi untuk Pod.
• containers:: Mendaftar container yang akan dijalankan di setiap Pod.
  • - name: server: Nama container. Ini digunakan untuk identifikasi di dalam Pod.
  • image: simple-go: Menentukan image container yang akan digunakan. Kubernetes akan mencari image ini di container registry atau lingkungan Docker lokal Minikube.
  • imagePullPolicy: Never: Karena Minikube kita lokal, kita perlu menentukan kebijakan pull image menjadi Never agar tidak mencoba menarik dari container registry tetapi menggunakan image lokal.
  • ports:: Mendaftar port yang diekspos oleh container.
    • - containerPort: 8080: Nomor port yang didengarkan oleh container. Ini memungkinkan Kubernetes merutekan traffic ke port yang benar di dalam container.

Menerapkan

Mari kita terapkan konfigurasi deployment menggunakan perintah kubectl apply -f deployment.yaml.

➜ kubectl apply -f deployment.yaml
deployment.apps/simple-go created

Kemudian kita dapat memeriksa pod menggunakan kubectl get pods. Kita akan memiliki 3 pod yang berjalan seperti ini.

➜ kubectl get pods
NAME                         READY   STATUS    RESTARTS   AGE
simple-go-65d7fccbfc-4f7xk   1/1     Running   0          10s
simple-go-65d7fccbfc-bgqlt   1/1     Running   0          10s
simple-go-65d7fccbfc-ltzgv   1/1     Running   0          10s

Mengakses Aplikasi

Kita berhasil menerapkan aplikasi, tetapi aplikasi belum dapat diakses. Kita akan belajar cara membuat service untuk membuat aplikasi kita dapat diakses, tetapi untuk saat ini kita dapat melakukan port forward menggunakan perintah kubectl port-forward <pod-name> <source-port>:<target-port>.

➜ kubectl port-forward simple-go-65d7fccbfc-4f7xk 8080:8080
Forwarding from 127.0.0.1:8080 -> 8080
Forwarding from [::1]:8080 -> 8080

Coba lagi menggunakan curl ke localhost port 8080 dan kita akan mendapatkan respons seperti ini:

➜ curl http://127.0.0.1:8080 
{"message":"Success"}

Referensi

• https://kubernetes.io/docs/concepts/workloads/controllers/deployment/
• https://kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster/