GitOps with ArgoCD: Declarative Kubernetes Deployments

Our Kubernetes deployments were manual. kubectl commands, no version control, deployment errors.

Implemented GitOps with ArgoCD. Deployment 30min → 2min, zero manual changes, full audit trail.

Table of Contents

Installation

# Create namespace
kubectl create namespace argocd

# Install ArgoCD
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

# Access UI
kubectl port-forward svc/argocd-server -n argocd 8080:443

# Get admin password
kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d

Repository Structure

gitops-repo/
├── apps/
│   ├── production/
│   │   ├── frontend/
│   │   │   ├── deployment.yaml
│   │   │   ├── service.yaml
│   │   │   └── ingress.yaml
│   │   └── backend/
│   │       ├── deployment.yaml
│   │       └── service.yaml
│   └── staging/
│       ├── frontend/
│       └── backend/
└── argocd/
    ├── applications/
    │   ├── frontend-prod.yaml
    │   └── backend-prod.yaml
    └── projects/
        └── myapp.yaml

Application Definition

# argocd/applications/frontend-prod.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: frontend-prod
  namespace: argocd
spec:
  project: myapp
  
  source:
    repoURL: https://github.com/myorg/gitops-repo
    targetRevision: main
    path: apps/production/frontend
  
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
      allowEmpty: false
    syncOptions:
    - CreateNamespace=true
    retry:
      limit: 5
      backoff:
        duration: 5s
        factor: 2
        maxDuration: 3m

Deployment Manifests

# apps/production/frontend/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  namespace: production
spec:
  replicas: 3
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
        version: v1.2.0
    spec:
      containers:
      - name: frontend
        image: myregistry/frontend:v1.2.0
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: frontend
  namespace: production
spec:
  selector:
    app: frontend
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP

Multi-Environment with Kustomize

# apps/base/frontend/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
- deployment.yaml
- service.yaml

commonLabels:
  app: frontend

# apps/production/frontend/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

bases:
- ../../base/frontend

namespace: production

replicas:
- name: frontend
  count: 3

images:
- name: myregistry/frontend
  newTag: v1.2.0

# apps/staging/frontend/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

bases:
- ../../base/frontend

namespace: staging

replicas:
- name: frontend
  count: 1

images:
- name: myregistry/frontend
  newTag: v1.2.0-rc1

Deployment Workflow

# 1. Update image tag in Git
cd gitops-repo
sed -i 's/v1.2.0/v1.3.0/g' apps/production/frontend/kustomization.yaml
git add .
git commit -m "Update frontend to v1.3.0"
git push

# 2. ArgoCD automatically syncs (if auto-sync enabled)
# Or manually sync:
argocd app sync frontend-prod

# 3. Monitor deployment
argocd app get frontend-prod
argocd app wait frontend-prod --health

Rollback

# Rollback to previous version
git revert HEAD
git push

# ArgoCD automatically syncs back
# Or manually:
argocd app sync frontend-prod

Health Checks

# Custom health check
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: frontend-prod
spec:
  # ... other config
  
  # Custom health assessment
  ignoreDifferences:
  - group: apps
    kind: Deployment
    jsonPointers:
    - /spec/replicas
  
  # Sync waves for ordered deployment
  syncPolicy:
    syncOptions:
    - CreateNamespace=true

Notifications

# argocd-notifications-cm ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: argocd-notifications-cm
  namespace: argocd
data:
  service.slack: |
    token: $slack-token
  
  template.app-deployed: |
    message: |
      Application {{.app.metadata.name}} is now running new version.
    slack:
      attachments: |
        [{
          "title": "{{ .app.metadata.name}}",
          "title_link":"{{.context.argocdUrl}}/applications/{{.app.metadata.name}}",
          "color": "#18be52",
          "fields": [
          {
            "title": "Sync Status",
            "value": "{{.app.status.sync.status}}",
            "short": true
          },
          {
            "title": "Repository",
            "value": "{{.app.spec.source.repoURL}}",
            "short": true
          }
          ]
        }]
  
  trigger.on-deployed: |
    - when: app.status.operationState.phase in ['Succeeded']
      send: [app-deployed]

CI/CD Integration

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  update-gitops:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - name: Build and push image
        run: |
          docker build -t myregistry/frontend:${{ github.sha }} .
          docker push myregistry/frontend:${{ github.sha }}
      
      - name: Update GitOps repo
        run: |
          git clone https://github.com/myorg/gitops-repo
          cd gitops-repo
          sed -i "s|newTag:.*|newTag: ${{ github.sha }}|" apps/production/frontend/kustomization.yaml
          git add .
          git commit -m "Update frontend to ${{ github.sha }}"
          git push

Results

Deployment:

• Time: 30min → 2min (-93%)
• Manual steps: 10 → 0
• Errors: 20% → 0%
• Rollback time: 15min → 1min

Audit Trail:

• Git history: ✅
• Who deployed: ✅
• When deployed: ✅
• What changed: ✅

Developer Experience:

• No kubectl needed: ✅
• Self-service: ✅
• Preview changes: Git diff
• Confidence: High

Reliability:

• Drift detection: ✅
• Auto-healing: ✅
• Declarative: 100%
• Reproducible: ✅

Lessons Learned

1. GitOps simplifies deployments: 93% faster
2. Declarative better: No manual changes
3. Auto-sync powerful: Zero-touch deployments
4. Kustomize helps: Multi-environment
5. Audit trail valuable: Full history

Conclusion

GitOps with ArgoCD transformed our deployments. Time 30min → 2min, zero manual kubectl, full audit trail.

Key takeaways:

1. Deployment time: 30min → 2min (-93%)
2. Manual steps: 10 → 0
3. Deployment errors: 20% → 0%
4. Rollback: 15min → 1min
5. 100% declarative

Implement GitOps. Deployments should be boring.