ArgoCD — GitOps Continuous Delivery

Čo je ArgoCD a prečo GitOps?

ArgoCD je deklaratívny GitOps continuous delivery nástroj pre Kubernetes. Funguje na jednoduchom princípe — Git repozitár je single source of truth pre definíciu želaného stavu aplikácií a infraštruktúry.

Prečo GitOps?

Tradičný CI/CD push model má niekoľko nevýhod — CI pipeline priamo aplikuje zmeny do clustra, čo vytvára bezpečnostné riziká a sťažuje audit. GitOps tento model obracia:

• Deklaratívny stav — celá konfigurácia je v Gite
• Automatická synchronizácia — ArgoCD neustále porovnáva želaný stav (Git) so skutočným stavom (cluster)
• Audit trail — každá zmena je git commit s autorom, časom a dôvodom
• Rollback — návrat na predchádzajúcu verziu = git revert
• Self-healing — ak niekto manuálne zmení niečo v clustri, ArgoCD to deteguje a opraví

---

Architektúra ArgoCD

ArgoCD beží ako sada microservices priamo v Kubernetes clustri:

Application Controller

Jadro ArgoCD. Neustále monitoruje bežiace aplikácie a porovnáva ich aktuálny stav so želaným stavom definovaným v Git repozitári. Ak deteguje drift (odchýlku), označí aplikáciu ako OutOfSync.

• Sleduje Kubernetes resources cez watch mechanizmus
• Vykonáva sync operácie (apply manifestov)
• Podporuje health checks pre custom resources

Repo Server

Zodpovedá za komunikáciu s Git repozitármi:

• Klonuje a cachuje repozitáre
• Generuje Kubernetes manifesty z rôznych zdrojov (Helm, Kustomize, plain YAML, Jsonnet)
• Beží ako stateless služba — dá sa horizontálne škálovať

API Server

Poskytuje rozhranie pre používateľov a externé systémy:

• gRPC/REST API pre programový prístup
• Web UI — prehľadný dashboard so stavom aplikácií
• CLI (argocd) — plnohodnotný command-line klient
• SSO integrácia — OIDC, SAML, LDAP
• Spravuje RBAC politiky a autentifikáciu

Redis

Používa sa ako cache layer pre dáta API servera a aplikačný stav — zrýchľuje odozvu UI a API.

Dex (voliteľný)

Identity provider pre SSO integráciu — ArgoCD ho používa na pripojenie externých identity providerov.

---

Sync stratégie

ArgoCD ponúka flexibilné stratégie synchronizácie aplikácií:

Auto-Sync

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
spec:
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
      allowEmpty: false

• automated — automaticky synchronizuje pri detekcii zmien v Gite
• selfHeal — opraví manuálne zmeny v clustri (drift correction)
• allowEmpty — ochrana pred vymazaním všetkých resources pri prázdnom manifeste

Manual Sync

Predvolená stratégia. ArgoCD deteguje zmeny a označí aplikáciu ako OutOfSync, ale čaká na manuálny trigger:

argocd app sync my-app

Vhodné pre produkčné prostredia, kde chcete explicitné schválenie pred deploymentom.

Prune

Prune riadi, čo sa stane s Kubernetes resources, ktoré už nie sú definované v Gite:

• prune: true — automaticky vymaže osirelé resources
• prune: false — resources zostanú (bezpečnejšie, ale vyžaduje manuálny cleanup)

Sync Options

syncPolicy:
  syncOptions:
    - CreateNamespace=true
    - PrunePropagationPolicy=foreground
    - PruneLast=true
    - ApplyOutOfSyncOnly=true
    - ServerSideApply=true

• PruneLast — najprv aplikuje nové resources, potom vymaže staré
• ServerSideApply — používa server-side apply namiesto kubectl apply
• ApplyOutOfSyncOnly — synchronizuje len zmenené resources (rýchlejšie)

---

Application a ApplicationSet

Application

Základná jednotka v ArgoCD — definuje jednu aplikáciu:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: frontend
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/org/app.git
    targetRevision: main
    path: k8s/overlays/production
  destination:
    server: https://kubernetes.default.svc
    namespace: frontend

Kľúčové polia:

• source — odkiaľ brať manifesty (Git repo, Helm chart)
• destination — kam deployovať (cluster + namespace)
• project — AppProject pre izoláciu a RBAC

ApplicationSet

Generátor pre dynamické vytváranie Applications — ideálny pre multi-tenant a multi-cluster scenáre:

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: microservices
spec:
  generators:
    - git:
        repoURL: https://github.com/org/apps.git
        directories:
          - path: services/*
  template:
    metadata:
      name: '{{path.basename}}'
    spec:
      source:
        repoURL: https://github.com/org/apps.git
        path: '{{path}}'
      destination:
        server: https://kubernetes.default.svc
        namespace: '{{path.basename}}'

Typy generátorov:

• Git — generuje apps z adresárovej štruktúry alebo súborov v repo
• Cluster — generuje app pre každý registrovaný cluster
• Matrix — kombinácia viacerých generátorov (napr. cluster × environment)
• Pull Request — vytvára preview environments pre každý PR
• List — statický zoznam parametrov

---

Multi-cluster management

ArgoCD exceluje v správe viacerých Kubernetes clustrov z jedného miesta:

Registrácia clustrov

# Pridanie clustra cez CLI
argocd cluster add staging-cluster --name staging

# Zobrazenie registrovaných clustrov
argocd cluster list

Hub-and-Spoke model

Jeden centrálny ArgoCD cluster (hub) spravuje aplikácie na viacerých cieľových clustroch (spokes):

• Centralizovaná správa — jeden dashboard pre všetky prostredia
• Konzistentný deployment — rovnaké manifesty, rôzne clustre
• Network requirements — ArgoCD potrebuje prístup k API serverom cieľových clustrov

Best practices pre multi-cluster

• Používajte ApplicationSet s cluster generátorom pre automatický deployment na všetky clustre
• Oddeľte konfiguráciu per-cluster cez Kustomize overlays alebo Helm values
• Nastavte cluster-specific RBAC — obmedzite, kto môže deployovať kam
• Monitorujte health status každého clustra zvlášť

---

RBAC a SSO integrácia

RBAC (Role-Based Access Control)

ArgoCD má vlastný RBAC systém definovaný v ConfigMap:

apiVersion: v1
kind: ConfigMap
metadata:
  name: argocd-rbac-cm
data:
  policy.csv: |
    p, role:developer, applications, get, */*, allow
    p, role:developer, applications, sync, */dev-*, allow
    p, role:admin, applications, *, */*, allow
    g, dev-team, role:developer
    g, platform-team, role:admin
  policy.default: role:readonly

Formát: p, role, resource, action, object, effect

• Resources: applications, clusters, repositories, projects
• Actions: get, create, update, delete, sync, override
• Object pattern: project/application s wildcard podporou

SSO integrácia

ArgoCD podporuje SSO cez OIDC (OpenID Connect):

apiVersion: v1
kind: ConfigMap
metadata:
  name: argocd-cm
data:
  oidc.config: |
    name: Keycloak
    issuer: https://keycloak.example.com/realms/devops
    clientID: argocd
    clientSecret: $oidc.keycloak.clientSecret
    requestedScopes:
      - openid
      - profile
      - email
      - groups

Podporované identity providers:

• Keycloak, Okta, Azure AD — cez OIDC
• GitHub, GitLab — cez Dex connector
• LDAP/Active Directory — cez Dex LDAP connector
• SAML 2.0 — pre enterprise prostredia

---

Porovnanie s Flux

Aspekt	ArgoCD	Flux
UI	Bohatý web dashboard	Žiadne natívne UI (Weave GitOps)
Architektúra	Centralizovaný (hub-spoke)	Decentralizovaný (per-cluster)
Multi-cluster	Natívna podpora	Cez Kubernetes API
Helm podpora	Helm template → apply	Natívny HelmRelease controller
Image automation	Externý (Argo Image Updater)	Vstavaný Image Automation
Notifications	Argo Notifications	Flux Notification Controller
RBAC	Vlastný RBAC systém	Kubernetes RBAC
Krivka učenia	Strmšia, viac features	Jednoduchší štart
CRDs	Application, AppProject, ApplicationSet	GitRepository, Kustomization, HelmRelease

Kedy ArgoCD?

• Potrebujete centrálny dashboard pre všetky clustre
• Chcete granulárny RBAC nezávislý od Kubernetes RBAC
• Máte väčšie tímy s rôznymi úrovňami prístupu
• Preferujete UI-first prístup

Kedy Flux?

• Preferujete decentralizovaný model (každý cluster si spravuje sám)
• Chcete natívnu image automation (auto-update pri novom image)
• Uprednostňujete Kubernetes-natívny prístup (štandardné RBAC)
• Máte jednoduchšie prostredie s menším počtom tímov

---

Best Practices

1. Oddeľte app repo a config repo

Držte aplikačný kód a Kubernetes manifesty v separátnych repozitároch. Zmeny v konfigurácii nepotrebujú rebuild image.

2. Používajte AppProjects

Izolujte tímy a prostredia pomocou AppProjects:

apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: team-frontend
spec:
  sourceRepos:
    - 'https://github.com/org/frontend-*'
  destinations:
    - namespace: 'frontend-*'
      server: '*'
  clusterResourceWhitelist:
    - group: ''
      kind: Namespace

3. Sync Waves a Hooks

Riaďte poradie deploymentu pomocou sync waves:

metadata:
  annotations:
    argocd.argoproj.io/sync-wave: "-1"  # deployne sa pred wave 0

Použite hooks pre migrácie, seeding a cleanup:

metadata:
  annotations:
    argocd.argoproj.io/hook: PreSync
    argocd.argoproj.io/hook-delete-policy: HookSucceeded

4. Health Checks pre custom resources

Definujte custom health checks pre CRDs, ktoré ArgoCD natívne nepozná:

apiVersion: v1
kind: ConfigMap
metadata:
  name: argocd-cm
data:
  resource.customizations.health.databases.example.com_PostgreSQL: |
    hs = {}
    if obj.status ~= nil then
      if obj.status.ready == true then
        hs.status = "Healthy"
      else
        hs.status = "Progressing"
      end
    end
    return hs

5. Notifikácie

Nastavte Argo Notifications pre alerting cez Slack, Teams alebo email:

apiVersion: v1
kind: ConfigMap
metadata:
  name: argocd-notifications-cm
data:
  trigger.on-sync-failed: |
    - when: app.status.sync.status == 'OutOfSync'
      send: [app-sync-failed]
  template.app-sync-failed: |
    message: |
      Application {{.app.metadata.name}} sync failed!

6. Ďalšie odporúčania

• Zapnite auto-prune v non-prod prostrediach, manuálne prune v produkcii
• Používajte sealed-secrets alebo external-secrets — nikdy necommitujte plain secrets do Gitu
• Limitujte blast radius — jedno ApplicationSet per tím/prostredie
• Monitorujte ArgoCD samotný cez Prometheus metriky (argocd-metrics)
• Pravidelne upgradujte — ArgoCD má rýchly release cyklus s bezpečnostnými patchmi