23. Penyiapan infrastruktur sebagai kode

Estimasi waktu penyelesaian: 60 menit

Pemilik komponen yang dapat dioperasikan: IAC

Profil keterampilan: engineer deployment

Infrastructure as Code (IaC) dalam konfigurasi air gap Google Distributed Cloud (GDC) terdiri dari dua sistem:

• Config Sync adalah komponen yang digunakan dalam Distributed Cloud Infrastructure as Code (IaC) untuk mengelola resource tingkat cluster dan layanan bersama.

• GitLab menghosting repositori Git yang berfungsi sebagai sumber tepercaya (SoT) untuk Config Sync. Cluster target adalah cluster yang dikelola Config Sync dari SoT di repositori.

  • GitLab menyertakan sistem peninjauan kode untuk menerapkan persetujuan multi-pihak (MPA) pada perubahan kebijakan dan konfigurasi.

Dua jenis zona berikut terlibat dalam deployment:

• Zona anchor: Zona yang sudah menjadi bagian dari bidang kontrol global. Zona pertama adalah zona anchor deployment.
• Zona yang bergabung: Zona yang bergabung dengan bidang kontrol global.

Config Sync mengelola objek Kubernetes di cluster root-admin dan organization-admin. Repositori ini dikonfigurasi untuk membaca dari repositori IaC Distributed Cloud yang disediakan oleh GitLab di cluster root-admin utama.

Distributed Cloud menginstal IaC selama proses bootstrap. Jalankan langkah-langkah manual berikut untuk menyelesaikan penyiapan IaC.

Penting: Untuk mengakses URL yang tercantum di halaman ini, Anda harus terhubung ke internet. URL disediakan untuk mengakses di luar lingkungan air-gapped Anda.

23.1. Menyiapkan IaC zona pertama

Bagian ini mencakup langkah-langkah untuk menyiapkan IaC di zona deployment pertama.

23.2. Prasyarat

• Melakukan bootstrapping cluster admin root.
• Buat klien SAML di instance Active Directory Federation Services (ADFS) OC IT sebagai klien federasi identitas di GitLab.

23.3. Akses Hari ke-0 ke GitLab

1. Buka konsol web GitLab di https://iac.GDC_URL. GDC_URL adalah domain yang telah ditentukan dalam CIQ.

   # Use the root kubeconfig of the root admin cluster.
   export ANCHOR_KUBECONFIG=ANCHOR_ZONE_KUBECONFIG
   echo https://$(kubectl --kubeconfig $ANCHOR_KUBECONFIG get dnsregistrations \
        -n gitlab-system iac -o jsonpath='{.status.fqdn}')
   

2. Gunakan nama pengguna hari ke-0: ioadmin.

3. Jalankan perintah berikut untuk mendapatkan sandi:

   export IO_ADMIN_PWD=$(kubectl --kubeconfig $ANCHOR_KUBECONFIG \
     get secret gitlab-basic-users -n gitlab-system  \
     -o jsonpath='{.data.admin}' | base64 -d)
   

4. Login dan buka Menu > Projects > Explore Projects gdch / iac untuk memverifikasi bahwa repositori Git iac telah dibuat.

23.4. Membuat pengguna administrator

1. Buat pengguna administrator khusus di ADFS. Anda tidak boleh menggunakannya untuk tujuan non-administratif dan harus memiliki ekstensi "-ga". Perhatikan bahwa pengguna administrator awal Anda HARUS menggunakan email yang sama di sini dengan yang mereka gunakan di Active Directory Federation Services (ADFS).

2. Jalankan perintah berikut untuk membuat pengguna baru:

   export NEW_USER_NAME=NEW_USER_NAME
   export NEW_USER_USERNAME=NEW_USERNAME
   export NEW_USER_PWD=NEW_USER_PWD
   export NEW_USER_EMAIL=NEW_USER_EMAIL
   export GDC_URL=GDC_URL
   export TOKEN=$(curl -X POST https://iac.$GDC_URL/oauth/token \
       -d "grant_type=password&username=ioadmin&password=${IO_ADMIN_PWD}" \
       | jq -r '.access_token')
   USERID=$(curl -X GET https://iac.$GDC_URL/api/v4/users \
       -d access_token=${TOKEN} -d username=ioadmin |\
       sed -E 's/.*"id":"?([^,"]*)"?.*/\1/')
   curl -X POST https://iac.$GDC_URL/api/v4/users \
       -d username=${NEW_USER_USERNAME} -d password=${NEW_USER_PWD} -d name=${NEW_USER_NAME} \
       -d email=${NEW_USER_EMAIL} -d admin=true -d access_token=${TOKEN} 
   curl -X POST https://iac.$GDC_URL/oauth/revoke \
       -d client_id=${USERID} -d "token=${TOKEN}"
   

Catatan: Untuk meningkatkan akses pengguna yang ada ke Administrator, pilih pengguna dari bagian Pengguna, lalu klik Edit. Buka bagian Akses, pilih Administrator, lalu klik Simpan.

23.5. Memperbarui lisensi GitLab

Banyak fitur GitLab memerlukan lisensi "Ultimate" agar dapat berfungsi. Pada langkah ini, Anda akan mengganti lisensi sementara yang dikirimkan bersama GDC dengan lisensi situs itu sendiri. Mengaktifkan GitLab EE dengan file lisensi atau kunci berisi detail lengkap.

Kunci lisensi situs yang Anda terima adalah file teks ASCII yang dienkode base64 dengan ekstensi .gitlab-license. Anda akan menggunakan kunci ini untuk mengaktifkan GitLab.

1. Login ke konsol web GitLab sebagai ioadmin.
2. Di menu navigasi, pilih Menu, lalu Admin.
3. Di menu navigasi, pilih Setelan, lalu Umum.
4. Di area Tambahkan Lisensi, tambahkan lisensi dengan mengupload file atau memasukkan kunci.
5. Centang kotak Persyaratan Layanan.
6. Pilih Tambahkan lisensi.

23.6. Menyiapkan repositori GitLab

ConfigSync mengelola objek Kubernetes di cluster root-admin dan cluster org-admin serta dikonfigurasi untuk membaca dari repositori IaC Distributed Cloud yang disediakan oleh GitLab di cluster root-admin.

Kita perlu menyiapkan folder GitLab awal agar Configsync dapat menggunakan konfigurasi dan menerapkannya ke cluster Kubernetes yang diperlukan.

infrastructure
│   └── zonal
│     └── zones
│         ├── ${anchor_zone_name}
│           ├── root-admin
│             ├── kustomization.yaml
│   └── global
│     └── orgs
│         ├── root
│           ├── kustomization.yaml

Ikuti langkah-langkah untuk membuat struktur file awal:

1. Buka repositori iac dari "Menu -> Explore Projects".

2. Buka "Web IDE".

3. Buat file di /infrastructure/zonal/zones/${anchor_zone_name}/root-admin/kustomization.yaml dengan konten berikut:

   apiVersion: kustomize.config.k8s.io/v1beta1
   kind: Kustomization
   metadata:
     name: root-admin-kustomization
   

4. Klik tombol "Commit".

5. Pilih "Commit to the main branch" dan konfirmasi.

23.7. Menyiapkan persetujuan banyak pihak (MPA)

Gunakan bagian ini untuk mengonfigurasi sistem agar mewajibkan persetujuan pada setiap permintaan penggabungan ke repositori iac dan mencegah commit langsung (tanpa membuat permintaan penggabungan) ke cabang main untuk menerapkan persetujuan banyak pihak (MPA).

23.7.1. Mengaktifkan persetujuan permintaan penggabungan di GitLab

1. Buka repositori iac.

2. Gunakan IDE web untuk membuat file bernama CODEOWNERS di folder root dan tambahkan grup Distributed Cloud sebagai pemilik repositori sebagai langkah pertama:

   [Repository Owners]
   * @gdch
   

   Hanya pengguna yang ditambahkan ke file CODEOWNERS yang dapat menyetujui permintaan penggabungan di repositori iac. File generik ini hanya untuk tujuan penyiapan. Petunjuk yang lebih mendetail untuk izin persetujuan terperinci dijelaskan dalam IAC-R0007.

3. Klik tombol Commit.

4. Pilih Commit to the main branch dan konfirmasi.

5. Untuk menambahkan lebih banyak pengguna ke file CODEOWNERS, buat permintaan penggabungan yang akan disetujui oleh pengguna yang ada di CODEOWNERS.

Catatan: GDC menonaktifkan token peniruan identitas di GitLab untuk menerapkan otorisasi banyak pihak. Untuk mengetahui detail tentang token peniruan, lihat dokumentasi GitLab di https://docs.gitlab.com/ee/api/rest/index.html#impersonation-tokens.

23.8. Menghubungkan Active Directory Federation Services (ADFS) ke GitLab

Peringatan: Menghubungkan penyedia identitas ke GitLab akan menghapus metode login nama pengguna dan sandi default dari UI GitLab. Karena ioadminpengguna tidak tersedia, buat admin awal.

Anda dapat menghubungkan ADFS ke GitLab dengan klien SAML menggunakan framework Auth GitLab.

Jika Anda menggunakan otoritas sertifikat pribadi untuk penyedia identitas, Anda harus menambahkannya ke instance GitLab. Dapatkan sertifikat CA ADFS versi base64 dan masukkan ke dalam secret.

cat <<EOF > adfs-ca-cert-secret.yaml
apiVersion: v1
data:
  tls.crt: ADFS_CA_CERTIFICATE_BASE64
kind: Secret
metadata:
  name: adfs-ca-cert-secret
  namespace: gitlab-system
type: Opaque
EOF

kubectl apply -f adfs-ca-cert-secret.yaml

23.8.1. Mengonfigurasi ADFS untuk autentikasi SAML

Sebelum Anda menghubungkan GitLab ke ADFS menggunakan konfigurasi helm, ADFS harus membuat klien SAML. Di instance Windows Anda, ikuti langkah-langkah berikut:

1. Jalankan aplikasi AD FS Management sebagai administrator.

   

2. Di direktori AD FS, klik folder Relying Party Trust. Di panel Actions, klik Add Relying Party Trust.

   

3. Wizard Tambahkan Kepercayaan Pihak Tepercaya akan terbuka. Untuk langkah pertama, pilih Claims aware, lalu klik Start.

   

4. Pilih Masukkan data tentang pihak tepercaya secara manual, lalu klik Berikutnya.

   

5. Masukkan beberapa informasi yang dapat dikenali tentang instance ADFS di kolom Display Name dan Notes. Klik Berikutnya.

   

6. Lewati langkah Konfigurasi Sertifikat dengan mengklik Berikutnya.

7. Centang kotak Enable support for the SAML 2.0 WebSSO protocol. Di kolom Relying party SAML 2.0 SSO service URL, masukkan berikut ini: https://iac.GDC_URL/users/auth/saml/callback.

   Ganti GDC_URL dengan URL organisasi di GDC.

   

8. Beri nama IaC dan tambahkan kode berikut:

   https://iac.GDC_URL.sesame.street https://iac.GDC_URL.sesame.street/users/auth/saml/callback
   

9. Klik Berikutnya untuk langkah-langkah Konfigurasi ID, Pilih Kebijakan Kontrol Akses, dan Siap Menambahkan Kepercayaan untuk menyelesaikan wizard.

   Catatan: Untuk melewati langkah-langkah di halaman Konfigurasi ID, tambahkan ID Pihak Tepercaya berikut:

     # Replace GDC_URL with the cells URL, for example, bert.sesame.street
     https://iac.GDC_URL
     https://iac.GDC_URL/users/auth/saml/callback
   

10. Layar akan diperbarui dengan kepercayaan pihak tepercaya yang baru dibuat. Klik kanan item Anda, lalu pilih Edit Claim Issuance Policy.

    

11. Klik tombol Tambahkan aturan, di langkah Pilih Jenis Aturan, pilih Template Aturan Klaim dari Kirim Atribut LDAP sebagai Klaim. Klik Berikutnya.

12. Pada langkah Konfigurasi Aturan Klaim, selesaikan parameter berikut:

    1. Di kolom Nama aturan klaim, masukkan Email.
    2. Dalam daftar Attribute Store, pilih Active Directory.
    3. Di tabel Pemetaan atribut LDAP ke jenis klaim keluar, di kolom Atribut LDAP, pilih atau ketik E-Mail-Addresses.

    4. Di kolom Jenis klaim keluar dalam tabel, pilih atau ketik E-Mail Address.

       

    5. Selesaikan wizard.

13. Klik tombol Tambahkan aturan.

14. Klik kanan item, lalu klik Edit Claim Issuance Policy pada item lagi.

15. Pada langkah Choose Rule Type, pilih Claim Rule Template dari Transform an Incoming Claim. Klik Next.

16. Pada langkah Konfigurasi Aturan Klaim, selesaikan parameter berikut:

    1. Di kolom Nama aturan klaim, masukkan Transform email to nameid.
    2. Di kolom Jenis klaim masuk, pilih atau ketik E-Mail Address.
    3. Di kolom Outgoing claim type, pilih atau ketik Name ID.
    4. Di kolom Outgoing name ID format, pilih atau ketik Persistent Identifier.

    5. Pilih opsi Lewati semua nilai klaim.

       

    6. Selesaikan wizard.

23.8.2. Menambahkan konfigurasi SAML ke GitLab

Bagian ini memberikan langkah-langkah untuk menambahkan konfigurasi SAML ke Gitlab.

23.8.2.1. Mendaftarkan GitLab di penyedia identitas

Buka konfigurasi klien SAML Anda di ADFS. GitLab memerlukan nilai berikut untuk berintegrasi dengan IdP Anda:

• assertion_customer_service_url - IdP mengalihkan ke URL ini setelah mengautentikasi pengguna. Tetapkan ke https://iac.GDC_URL/users/auth/saml/callback.

  Ganti GDC_URL dengan URL organisasi di GDC.

• idp_cert_fingerprint - GitLab menggunakan sidik jari ini untuk memverifikasi sertifikat pesan SAML yang masuk. Untuk menemukan idp_cert_fingerprint di ADFS, ikuti langkah-langkah berikut:

  1. Jalankan aplikasi AD FS Management sebagai administrator.

  2. Di struktur direktori AD FS > Service > Certificates, klik folder Certificates. Anda akan melihat sertifikat di bagian Token-signing. Klik kanan sertifikat tersebut, lalu pilih Lihat Sertifikat.

     

  3. Di jendela Sertifikat, buka tab Details. Scroll daftar hingga Anda melihat item bernama Thumbprint. Klik item dan salin konten yang ditampilkan di konsol.

     

• idp_sso_target_url - GitLab akan menargetkan endpoint ini saat mengautentikasi dengan SAML. Untuk menemukan idp_sso_target_url di ADFS, ikuti langkah-langkah berikut:

  1. Jalankan aplikasi AD FS Management sebagai administrator.

  2. Klik folder Endpoints di struktur direktori AD FS > Service

     Endpoints.

     

  3. Di layar tengah, cari baris dengan jenis SAML 2.0/WS-Federation. Endpoint target adalah URL ADFS dan endpoint target. Misalnya, jika nama domain instance Anda adalah https://ocit.gdch.test/, dan endpoint target adalah /adfs/ls, maka idp_sso_target_url adalah https://ocit.gdch.test/adfs/ls.

• issuer - URL yang digunakan GitLab untuk mengidentifikasi dirinya sendiri. Gunakan https://iac.GDC_URL.

  Siapkan nilai IdP sebelumnya dan tulis ke konfigurasi kustom yang disebut custom_saml.yaml. Edit file YAML ini untuk mendapatkan konfigurasi yang diperlukan untuk klien SAML Anda.

  cat <<EOF > custom_saml.yaml
  name: saml
  label: "ADFS SAML" # This is the label the login button will use.
  args:
    assertion_consumer_service_url: "https://iac.GDC_URL/users/auth/saml/callback"
    idp_cert_fingerprint: "ADFS_IDP_CERT_FINGERPRINT"
    idp_sso_target_url: "ADFS_IDP_SSO_TARGET_URL"
    issuer: "https://iac.GDC_URL"
  
    # These parameters are necessary for ADFS to connect to GitLab. Do not change unless you are sure of what you're doing.
    name_identifier_format: "urn:oasis:names:tc:SAML:2.0:nameid-format:persistent"
    attribute_statements: { email: ['http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress'] }
  EOF
  

  Jika sudah siap, terapkan konfigurasi Anda sebagai rahasia yang disebut custom-gitlab-saml-provider.

  cat <<EOF > custom-gitlab-saml-provider.yaml
  apiVersion: v1
  data:
    provider: |
    $(cat custom_saml.yaml | base64 -w 0)
  kind: Secret
  metadata:
    name: custom-gitlab-saml-provider
    namespace: gitlab-system
    annotations:
      "helm.sh/hook": post-install,post-upgrade
      "helm.sh/hook-weight": "-5"
  EOF
  kubectl apply -f custom-gitlab-saml-provider.yaml
  

  Anda dapat menggunakan secret saat membuat subcomponentoverride.yaml. Pelajari lebih lanjut variabel di dokumentasi GitLab.

  cat <<EOF > subcomponentoverride.yaml
  apiVersion: lcm.private.gdc.goog/v1
  kind: SubcomponentOverride
  metadata:
    name: iac-gitlab
    namespace: root
  spec:
    subComponentRef: "iac-gitlab"
    backend:
      operableParameters:
        omniauth:
          enabled: true
          providers:
          - secret: custom-gitlab-saml-provider
        certificates:
          customCAs:
          - secret: adfs-ca-cert-secret
          - configMap: trust-store-root-ext
  EOF
  kubectl apply -f subcomponentoverride.yaml
  

Tindakan ini akan membuat penggantian subkomponen. Untuk memverifikasi bahwa konfigurasi telah dibuat, jalankan: sh kubectl get subcomponentoverride -n root

Outputnya mirip dengan hal berikut ini:

NAME            AGE
iac-gitlab   1s

23.8.2.2. Menginisialisasi pengguna SAML yang pertama kali login

Mengaktifkan SAML akan menghapus login lokal. Pengguna harus mengikuti prosedur akses darurat untuk mengaktifkan kembali login lokal dan mendapatkan akses ke ioadmin kembali.

Admin yang diinisialisasi pertama kali yang dibuat di Membuat pengguna administrator akan berfungsi tanpa modifikasi lebih lanjut sebagai admin. Mereka tidak boleh memiliki akses ke project. Untuk menambahkan pengguna ke project Distributed Cloud, ikuti Mengaktifkan pengguna baru dari ADFS.

23.8.3. Memverifikasi Koneksi ADFS

1. Periksa status pod webservice GitLab:

   kubectl --kubeconfig $KUBECONFIG get pod -l app=webservice,release=gitlab -n gitlab-system
   

   NAMA	SIAP	STATUS	MEMULAI ULANG	USIA
   gitlab-webservice-default-5d99b4d7c7-9fmln	2/2	Berjalan	0	4m6d
   gitlab-webservice-default-5d99b4d7c7-w99p4	2/2	Berjalan	0	96 dtk
   gitlab-webservice-default-7884d4c8b9-qjhtv	2/2	Mengakhiri	0	18 jam

2. Buka https://iac.GDC_URL dan pastikan Anda melihat layar ini, yang menampilkan tombol ADFS SAML untuk menggunakan login SSO dan tidak ada kolom nama pengguna dan sandi login langsung.

3. Klik ADFS SAML. Pastikan Anda diminta login ke ADFS.

4. Setelah login ke ADFS, pastikan Anda login ke GitLab, dan sekarang dapat berinteraksi dengan aplikasi.

23.9. Mengunci akun administrator Hari ke-0

Setelah SAML diaktifkan, nonaktifkan autentikasi sandi untuk antarmuka web, lalu reset sandi untuk ioadmin karena akses API tetap ada.

1. Jalankan skrip berikut.

   Catatan: Di lingkungan pengujian, tambahkan - k ke perintah curl.

     export KUBECONFIG=/root/release/root-admin/root-admin-kubeconfig
     export PWD=$(kubectl get secret gitlab-basic-users -n gitlab-system -o yaml \
         | grep admin | head -n1 | awk '{print $2}' | xargs echo | base64 -d)
     export TOKEN=$(curl -X POST https://iac.GDC_URL/oauth/token \
         -d "grant_type=password&username=ioadmin&password=${PWD}" \
         | jq -r '.access_token')
     curl -X PUT  https://iac.GDC_URL/api/v4/application/settings \
         -d access_token=${TOKEN} \
         -d password_authentication_enabled_for_web=false
     NEWPASS=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)
     USERID=$(curl -X GET https://iac.GDC_URL/api/v4/users \
         -d access_token=${TOKEN} -d username=ioadmin |\
         jq -r '.[] | .id')
     curl -X PUT  https://iac.GDC_URL/api/v4/users/${USERID} \
         -d access_token=${TOKEN} -d username=ioadmin \
         -d "password=${NEWPASS}" \
         -d user_id=${USERID}
     curl -X POST https://iac.GDC_URL/oauth/revoke \
         -d client_id=${USERID} -d "token=${TOKEN}"
   

2. Simpan sandi baru di rahasia gitlab-basic-users.

     kubectl patch secret gitlab-basic-users -n gitlab-system --type=json -p'[{"op": "replace", "path": "/data/admin", "value": '"$(echo $NEWPASS | base64 -w0)"'}]'
   

Gunakan akun di OI ADFS untuk login.

23.10. Menyiapkan IaC zona gabungan

Bagian ini menjelaskan langkah-langkah untuk menyiapkan IaC di zona bergabung dalam deployment.

23.11. Prasyarat

Sebelum menyiapkan zona bergabung, Anda harus mem-bootstrap cluster admin root.

23.12. Mengonfigurasi kredensial configsync

Ikuti langkah-langkah berikut untuk mengonfigurasi kredensial Config Sync:

1. Hubungkan ke cluster admin root zona anchor.

2. Ambil kredensial Config Sync:

   kubectl --kubeconfig $ANCHOR_KUBECONFIG get secret -n config-management-system iac-creds-replica -o json |\
       jq 'del(.metadata.creationTimestamp, .metadata.resourceVersion, .metadata.uid)' > iac-creds-replica.json
   

3. Salin file iac-creds-replica.json.

4. Hubungkan ke cluster admin root zona yang bergabung.

5. Tempelkan file iac-creds-replica.json.

6. Terapkan kredensial Config Sync ke cluster admin root:

   # Use the root kubeconfig of the root admin cluster.
   export JOINING_KUBECONFIG=JOINING_ZONE_KUBECONFIG
   kubectl --kubeconfig $JOINING_KUBECONFIG apply -f iac-creds-replica.json
   

7. Pastikan kredensial Config Sync dikonfigurasi:

   kubectl --kubeconfig $JOINING_KUBECONFIG get secret -n config-management-system \
       iac-creds-replica -o yaml
   

23.13. Mengonfigurasi sumber tepercaya Config Sync

Ikuti langkah-langkah berikut untuk mengonfigurasi sumber tepercaya Config Sync:

1. Hubungkan ke cluster admin root zona anchor.

2. Dapatkan FQDN GitLab:

   export primaryDnsFQDN=$(kubectl --kubeconfig $ANCHOR_KUBECONFIG get DNSRegistration \
       -n gitlab-system iac -o jsonpath='{.status.fqdn}')
   

3. Hubungkan ke cluster admin root zona yang bergabung.

4. Buat file SubcomponentOverride IaC:

   echo "apiVersion: lcm.private.gdc.goog/v1
   kind: SubcomponentOverride
   metadata:
       name: iac
       namespace: root
   spec:
       subComponentRef: "iac-configsync"
       backend:
           operableParameters:
               primaryDnsFQDN: ${primaryDnsFQDN}" > iac-subcomponentoverride.yaml
   

5. Konfigurasi target Config Sync:

   kubectl --kubeconfig $JOINING_KUBECONFIG apply -f iac-subcomponentoverride.yaml
   

6. Pastikan repositori Git Config Sync dikonfigurasi:

   kubectl --kubeconfig $JOINING_KUBECONFIG get RootSync -n config-management-system \
       root-sync -o jsonpath='{.spec.git.repo}'
   

7. Pastikan Config Sync tidak memiliki error di zona anchor dan zona gabungan.

   kubectl --kubeconfig $JOINING_KUBECONFIG get RootSync \
       -n config-management-system root-sync \
       -o jsonpath='{.status.source.errors[0].errorMessage}'
   

   1. Jika root-sync berisi error KNV2004, jalur direktori yang digunakan oleh anchor atau zona penggabungan tidak ada di repositori iac. Temukan direktori yang diperlukan dengan menjalankan:

      kubectl --kubeconfig $JOINING_KUBECONFIG get RootSync \
          -n config-management-system root-sync
          -o jsonpath='{.spec.git.dir}'
      

   2. Buat output jalur oleh perintah sebelumnya di repositori iac dan tambahkan file kustomization.yaml generik. Kemudian, gabungkan ke cabang main.

   3. Jalankan kembali perintah get RootSync asli, untuk memastikan Config Sync tidak memiliki error.