# GitOps dengan Argo CD

<figure><img src="/files/DnSvmAOxgZy49C8YLCtK" alt=""><figcaption></figcaption></figure>

Konsep Inti GitOps:

Git adalah satu-satunya sumber kebenaran (single source of truth). Kita tidak akan pernah lagi menjalankan kubectl apply -f ... secara manual. Kita akan mendeploy sebuah agent di dalam Kubernetes yang tugasnya adalah "memantau" repository Git, dan secara otomatis menyamakan state kluster dengan apa pun yang ada di repository itu.

Alat yang Kita Pakai:

* Git Repository (GitHub): Sebagai "sumber kebenaran" kita.
* Argo CD: Sebagai *agent* GitOps. Ini adalah *controller* yang akan kita *install* di dalam kluster `kind` kita.
* Kluster `kind`: Yang sudah Anda siapkan.

***

#### Langkah 0: Persiapan

Pastikan kluster `kind` Anda berjalan dan `kubectl` sudah terkonfigurasi.

#### Langkah 1: Siapkan "Config Repository" Anda

Ini adalah langkah paling penting. Anda perlu *repository* Git baru yang *hanya* berisi manifes YAML Kubernetes Anda.

1. Buat Repo Baru di GitHub:
   * Buatlah *repository* public baru. (Bisa juga *private*, tapi *public* lebih mudah untuk tutorial ini).
   * Misalnya, beri nama: `argocd-demo`
2. Clone Repo Baru dan Pindahkan File YAML Anda:

   Di terminal macOS Anda (di luar proyek Spring Boot):

   ```bash
   # Pindah ke direktori home atau tempat Anda biasa menyimpan kode
   cd ~

   # Clone repo yang baru Anda buat
   git clone https://github.com/semmidev/argocd-demo.git

   # Masuk ke direktori
   cd argocd-demo
   ```
3. Salin SEMUA file YAML Anda ke repo ini:
4. Commit dan Push:

   Bash

   ```
   git add .
   git commit -m "Initial Kubernetes manifests"
   git push origin main
   ```

PENTING: *Repository* ini sekarang adalah "sumber kebenaran" Anda.

***

#### Langkah 2: Bersihkan Kluster Anda (Wajib!)

Untuk membuktikan GitOps berfungsi, kita harus mulai dari kluster yang bersih. Hapus semua *resource* yang sudah Anda buat secara manual.

```bash
# Hapus semua resource dari sesi sebelumnya
kubectl delete -f /path/ke/7-app.yml
kubectl delete -f /path/ke/6-postgres.yml
kubectl delete -f /path/ke/2-configmap.yml
kubectl delete -f /path/ke/3-secret.yml
kubectl delete -f /path/ke/5-pvc.yml
kubectl delete -f /path/ke/4-pv.yml

# Pastikan tidak ada yang tersisa (kecuali resource 'kube-system')
kubectl get all -A
```

Kluster `kind` Anda sekarang harus kosong.

***

#### Langkah 3: Install Argo CD di Kluster `kind`

Sekarang kita *install* *agent* GitOps-nya.

```bash
# 1. Buat namespace khusus untuk Argo CD
kubectl create namespace argocd

# 2. Terapkan manifes instalasi Argo CD
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
```

Ini akan membuat banyak *deployment*, *service*, dll. di dalam *namespace* `argocd`.

#### Langkah 4: Akses Argo CD (UI)

Cara termudah untuk berinteraksi dengan Argo CD adalah melalui UI-nya. Kita akan menggunakan `port-forward`.

1. Buka Terminal BARU dan biarkan tetap berjalan:

   ```bash
   # Teruskan port UI Argo CD ke localhost:8081
   kubectl port-forward svc/argocd-server -n argocd 8081:443
   ```
2. Dapatkan Password Admin Awal:

   Password-nya disimpan di dalam secret Kubernetes.

   ```bash
   # Perintah ini akan mengambil dan men-decode password-nya
   kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo
   ```

   *Simpan password yang muncul.*
3. Login ke UI:
   * Buka browser Anda ke `https://localhost:8081` (Akan ada peringatan keamanan sertifikat, klik "Advanced" -> "Proceed").
   * Username: `admin`
   * Password: *Password* yang Anda dapatkan dari langkah sebelumnya.

***

#### Langkah 5: Buat "Aplikasi" di Argo CD

Sekarang kita akan memberitahu Argo CD untuk "memantau" *repository* Git Anda.

1. Di UI Argo CD, klik `+ NEW APP`.
2. Isi formulir:
   * Application Name: `my-demo-app`
   * Project Name: `default`
   * Sync Policy: `Manual` (Kita akan klik "Sync" secara manual untuk belajar).
3. Source:
   * Repository URL: URL GitHub Anda, misal: `https://github.com/sammidev/my-k8s-config.git`
   * Revision: `HEAD`
   * Path: `.` (Artinya *root* dari *repository*)
4. Destination:
   * Cluster URL: `https://kubernetes.default.svc` (Ini adalah kluster *in-cluster* tempat Argo CD berjalan).
   * Namespace: `default` (Ini adalah *namespace* tujuan tempat aplikasi Anda akan di-deploy).
5. Klik CREATE.

#### Langkah 6: Deploy dengan GitOps (The Magic!)

Anda akan melihat kartu `my-demo-app` dengan status `Missing` dan `OutOfSync`. Ini normal. Argo CD melihat bahwa *repo* Git Anda memiliki YAML, tetapi kluster Anda (di *namespace* `default`) masih kosong.

1. Klik kartu `my-demo-app` untuk melihat detailnya.
2. Anda akan melihat visualisasi semua *resource* Anda (ConfigMap, Secret, PV, PVC, StatefulSet, dll.).
3. Klik tombol Sync di bagian atas.
4. Biarkan semua opsi dicentang, lalu klik SYNCHRONIZE.

Apa yang terjadi? Argo CD sekarang akan membaca *semua* file YAML di *repo* Git Anda dan menjalankan `kubectl apply` untuk Anda.

Anda bisa melihat di UI, satu per satu resource akan dibuat dan menjadi Healthy. Anda juga bisa mengecek di terminal:

`kubectl get all,pv,pvc`

Semua aplikasi Anda (Postgres dan Spring Boot) akan menyala, tanpa Anda mengetik `kubectl` sama sekali.

***

#### Langkah 7: Praktek GitOps (Melakukan Upgrade)

Ini adalah bagian terpenting. Mari kita *upgrade* aplikasi kita.

Tugas: Ganti *image* dari `sammidev/demo-time:1.0.0` ke `sammidev/demo-time:1.1.0`.

CARA LAMA (JANGAN DILAKUKAN): `kubectl set image ...`&#x20;

CARA BARU (GIT-OPS):

1. Push image baru Anda (Asumsi sudah Anda lakukan):

   Anda sudah build dan push sammidev/demo-time:1.1.0.
2. Ubah Sumber Kebenaran (Git):
   * Di macOS Anda, buka *repository* `my-k8s-config` (bukan proyek Spring Boot).
   * Edit file `7-app.yml`.
   * Ubah baris *image*:

     ```yaml
     ...
           image: sammidev/demo-time:1.1.0 # <-- UBAH DI SINI
     ...
     ```
3. Commit dan Push Perubahan:

   ```bash
   git add 7-app.yml
   git commit -m "Upgrade demo-time-app to v1.1.0"
   git push origin main
   ```
4. Sync Perubahan:
   * Kembali ke UI Argo CD.
   * Setelah beberapa saat, status `my-demo-app` akan berubah menjadi `OutOfSync`.
   * Argo CD telah mendeteksi bahwa Git (v1.1.0) dan kluster (v1.0.0) sudah tidak sama.
   * Klik `my-demo-app`, lalu klik Sync lagi.

Argo CD akan melihat perbedaan kecil itu (hanya *image tag* di Deployment) dan hanya akan menerapkan perubahan itu, yang secara otomatis memicu *Rolling Update* di Kubernetes.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://lab-sammi.gitbook.io/me/gitops-dengan-argo-cd.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.