Hi sobat clonya!

Pada artikel ini kita akan membahas bagaimana mengintegrasikan Gitlab Agent for Kubernetes (AgentK) dan FluxCD, sebuah tool GitOps yang memungkinkan sinkronisasi otomatis antara konfigurasi di repository dan state aktual di cluster. Sehingga pengelolaan state cluster bisa lebih terpusat dan fleksibel dalam proses update maupun rollback.

Sebelum masuk ke step by stepnya, yuk dipahami dulu istilah penting agar lebih mudah memahami apa yang nanti akan kita konfigurasikan 🚀

Apa itu Kubernetes?

Perkembangan teknologi semakin cepat, termasuk datangnya teknologi baru yaitu container. Dengan menggunakan container, seluruh aplikasi dan dependensi yang kita butuhkan akan dikemas dan dijalankan dalam lingkungan yang terisolasi. Untuk menjalankan container, tentunya membutuhkan sebuah tools atau aplikasi manajemen container seperti Docker, Podman, atau Containerd.

Tetapi untuk kebutuhan production, tidak cukup hanya sekedar aplikasi bisa berjalan, kita membutuhkan sistem yang handal sehingga aplikasi kita selalu available, memiliki security yang handal, bisa menerima banyak traffic, dan sebagainya. Untuk itu diperlukan manajemen orkestrasi untuk menangani itu semua. Tools orkestrasi yang paling populer saat ini adalah Kubernetes (K8s).

Berikut 3 fitur dasar Kubernetes:

Autoscaling

Kubernetes bisa otomatis menambah atau mengurangi jumlah pod berdasarkan penggunaan CPU, memori, atau metrik kustom lainnya dengan Horizontal Pod Autoscaler (HPA) atau Vertical Pod Autoscaler (VPA)
Load Balancing & Service Discovery

Kubernetes secara otomatis mendistribusikan traffic ke Pods dan menyediakan mekanisme service discovery, sehingga aplikasi bisa berkomunikasi tanpa perlu konfigurasi manual
Self Healing

Jika sebuah Pod mengalami kegagalan, Kubernetes akan secara otomatis me-restart, menggantinya, atau menjadwalkan ulang ke node yang lain.

Apa itu Gitlab Agent?

Gitlab Agent adalah penengah antara repository Gitlab dengan cluster lokal. Dengan menggunakan Gitlab Agent kita bisa mengelola state cluster seperti mendeploy aplikasi, mengelola cluster, dan memantau kondisi kubernetes dari Gitlab.

Apa itu GitOps?

GitOps adalah metode manajemen infrastruktur yang menggunakan Git sebagai pusat kontrol. Dengan pendekatan ini, setiap perubahan pada sistem dilakukan melalui pull request di Git, memastikan otomatisasi dalam pembuatan, pembaruan, dan penghapusan infrastruktur. GitOps menggabungkan konsep Infrastructure as Code (IaC) dan praktik DevOps untuk memastikan sistem selalu sinkron dengan versi yang tersimpan di Git.

Apa itu FluxCD?

FluxCD adalah alat Continuous Delivery (CD) yang mengotomatiskan deployment aplikasi ke Kubernetes menggunakan konsep GitOps. Setiap kali ada perubahan kode di repository, FluxCD secara otomatis memperbarui aplikasi di klaster.

FluxCD bekerja dengan menjalankan controller di klaster Kubernetes yang rutin memeriksa pembaruan pada repository. Jika ada perubahan, FluxCD akan menambahkan, memperbarui, atau menghapus objek Kubernetes untuk memastikan klaster selalu dalam kondisi yang sesuai dengan konfigurasi di Git.

Setelah paham istilah di atas. kuy gas ke cara implementasinya🚀

Topologi

source controller berjalan sebagai pod di namespace flux-system untuk memantau perubahan yang terjadi di manifest-repo sedangkan kustomize controller akan menerapkan perubahan manifest ke cluster. Dalam contoh di atas akan membuat deployment dan service di namespace default

Implementasi

Persiapan

Pastikan kita mempunyai cluster kubernetes dan bisa berinteraksi menggunakan kubectl CLI
```
  ~$ kubectl version
```

Install Flux CLI

  ~$ curl -s https://fluxcd.io/install.sh | sudo bash
  ~$ .<(flux completion bash)

Install Gitlab CLI (glab)

  ~$ wget https://gitlab.com/gitlab-org/cli/-/releases/v1.53.0/downloads/glab_1.53.0_linux_amd64.tar.gz
  ~$ tar -xvzf glab_1.53.0_linux_amd64.tar.gz
  ~$ sudo mv bin/glab /usr/local/bin
  ~$ sudo chmod +x /usr/local/bin/glab

Cek apakah sudah terinstall dengan benar

  ~$ glab --version

Konfigurasikan Gitlab Agent

Buat Personal Access Token di Gitlab. Buat token dengan minimal scope yaitu api, k8s_proxy, read_repository, dan write_repository
Buat project baru bernama kube-agent. Repository ini yang akan menjadi repo utama tempat kita meregister agent dan memantau status cluster dari environment yang kita buat.

Bootstrap Flux

Proses ini akan mendeploy semua controller yang dibutuhkan di namespace flux-system.

  ~$ flux bootstrap gitlab \
     --hostname=gitlab.com \
     --owner=your_username \
     --repository=kube-agent \
     --path=./kube/manifest \
     --deploy-token-auth

  # Masukkan token yang sudah digenerate saat ada prompt token

Buat konfigurasi agent

Otentikasi gitlab akun menggunakan glab command
```
  ~$ glab auth login
```

Clone repo kube-agent

  ~$ glab repo clone https://gitlab.com/sansanstudy/kube-agent.git

Buat folder .gitlab/agents/<agent_name> di direktori kube-agent
```
  ~$ mkdir -p kube-agent/.gitlab/agents/agentk
```

Buat konfigurasi di .gitlab/agents/<agent_name>/config.yaml

   ~$ vim kube-agent/.gitlab/agents/agentk/config.yaml
  ...
  user_access:
    access_as:
        agent: {}
    projects:
        - id: sansanstudy/kube-agent

Register Gitlab Agent

Di repository kube-agent, masuk ke Operate - Kubernetes clusters
Klik Connect a cluster untuk membuat agent
Salin command yang muncul setelah membuat agent. Segera simpan command karena tidak akan muncul setelah refresh halaman web

Jalankan di cluster Kubernetes

  ~$ helm repo add gitlab https://charts.gitlab.io
    helm repo update
    helm upgrade --install agentk gitlab/gitlab-agent \
    --namespace gitlab-agent-agentk \
    --create-namespace \
    --set image.tag=v17.9.2 \
    --set config.token=Your_token \
    --set config.kasAddress=wss://gitlab.adinusa.id/-/kubernetes-agent/

    ...

    "gitlab" already exists with the same configuration, skipping
    Hang tight while we grab the latest from your chart repositories...
    ...Successfully got an update from the "gitlab" chart repository
    Update Complete. ⎈Happy Helming!⎈
    Release "agentk" has been upgraded. Happy Helming!

    ---Output ommited---

Cek status Agent

Buat Environment

Buat environment bernama Flux untuk memantau proses sinkronisasi
Buat environment ke dua bernama Kubernetes-cluster untuk memantau status cluster secara global
Cek environment flux
Cek environment Kubernetes-cluster

Konfigurasikan Gitlab Agent untuk multi-project

Buat project (repository) lain bernama manifest-repo untuk menyimpan konfigurasi manifest dari reource kubernetes
Buat Kubernetes secret baru dengan nama git-access-auth agar bisa pull manifest dari manifest-repo. Kita bisa gunakan token sebelumnya untuk membuat secretnya
```
  ~$ flux -n flux-system create secret git git-access-auth \
    --url=https://gitlab.com \
    --username=oauth2
    --password=PAT_TOKEN
```

Tambahkan repository manifest-repo di konfigurasi config.yaml

   ~$ vim kube-agent/.gitlab/agents/agentk/config.yaml
  ...
  user_access:
    access_as:
        agent: {}
    projects:
        - id: sansanstudy/kube-agent
        - id: sansanstudy/manifest-repo

Konfigurasikan GitRepository dan Kustomization untuk repository manifest-repo

  ~$ vim kube-agent/kube/manifest/flux-system/manifest-repo.yaml
  ...

  apiVersion: source.toolkit.fluxcd.io/v1
  kind: GitRepository
  metadata:
    name: manifest-repo
    namespace: flux-system
  spec:
    interval: 1m0s
    ref:
      branch: main
    secretRef:
      name: git-access-auth
    url: https://gitlab.com/sansanstudy/manifest-repo.git
  ---
  apiVersion: kustomize.toolkit.fluxcd.io/v1
  kind: Kustomization
  metadata:
    name: manifest-kust
    namespace: flux-system
  spec:
    interval: 10m0s
    path: ./
    prune: true
    sourceRef:
      kind: GitRepository
      name: manifest-repo

Konfigurasikan resource kustomization flux agar memuat kustomization dan GitRepository yang dibuat sebelumnya

  ~$ vim kube-agent/kube/manifest/flux-system/kustomization.yaml
  ...

  apiVersion: kustomize.config.k8s.io/v1beta1
  kind: Kustomization
  resources:
  - gotk-components.yaml
  - gotk-sync.yaml
  - manifest-repo.yaml # tambahkan baris ini

Jangan lupa untuk push perubahan tadi ke remote repository (kube-agent)

Testing Deployment

Buat file app-deploy.yaml di manifest-repo dengan nama deployment adalah test-deploy-agent
Buat file app-service.yaml di manifest-repo dengan nama service adalah test-service-agent
Cek hasil sinkronisasi di repo kube-agent
- Cek hasil deploy
- Cek hasil service

Kesimpulan

Dengan GitLab Agent for Kubernetes (AgentK) dan FluxCD, proses deployment menjadi lebih otomatis dan praktis. Setiap perubahan di repository GitLab langsung diterapkan ke cluster Kubernetes tanpa perlu campur tangan manual.

✨ Apa yang membuat ini keren?

✅ FluxCD memastikan semua manifest dari repo Git diterapkan dengan rapi melalui Source Controller dan Kustomize Controller.
✅ GitLab Agent menjaga koneksi tetap aman tanpa harus membuka akses API server ke publik.
✅ Lebih stabil & minim risiko – Deployment menjadi lebih terstruktur, bisa diulang dengan mudah, dan mengurangi potensi kesalahan manusia.

Referensi

Pengertian Kubernetes

https://medium.com/sannycloud/apa-itu-kubernetes-k8s-af4e68f7c358
Pengertian Gitlab Agent

https://docs.gitlab.com/user/clusters/agent/
Pengertian GitOps

https://www.atlassian.com/git/tutorials/gitops
Pengertian Flux

https://spacelift.io/blog/fluxcd
Konfigurasi Gitlab Agent dengan FluxCD

https://docs.gitlab.com/user/clusters/agent/getting_started/

Configure the Gitlab Agent with FluxCD

Table of contents