GitOps with ArgoCD on KubeBid

Step 3: Set Up Your Git Repository

Create a repository structure for your Kubernetes manifests:

my-app-config/
├── apps/
│   ├── production/
│   │   ├── deployment.yaml
│   │   ├── service.yaml
│   │   └── kustomization.yaml
│   └── staging/
│       ├── deployment.yaml
│       ├── service.yaml
│       └── kustomization.yaml
├── base/
│   ├── deployment.yaml
│   ├── service.yaml
│   └── kustomization.yaml
└── argocd/
    └── applications.yaml

Example base deployment:

# base/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: myorg/my-app:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: "100m"
            memory: "128Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"

# base/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
  - deployment.yaml
  - service.yaml

# apps/production/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
namespace: production
resources:
  - ../../base
replicas:
  - name: my-app
    count: 5
images:
  - name: myorg/my-app
    newTag: v1.2.3

Step 4: Create ArgoCD Applications

Define your applications in ArgoCD:

# argocd/applications.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-production
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/myorg/my-app-config.git
    targetRevision: main
    path: apps/production
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true        # Delete resources removed from Git
      selfHeal: true     # Revert manual changes
    syncOptions:
      - CreateNamespace=true
---
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-staging
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/myorg/my-app-config.git
    targetRevision: main
    path: apps/staging
  destination:
    server: https://kubernetes.default.svc
    namespace: staging
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true

Apply the applications:

kubectl apply -f argocd/applications.yaml

Step 5: Connect Your Git Repository

If your repository is private, add credentials:

# Using the CLI
argocd login argocd.your-domain.com

# Add repository with SSH key
argocd repo add git@github.com:myorg/my-app-config.git \
  --ssh-private-key-path ~/.ssh/id_rsa

# Or with HTTPS and token
argocd repo add https://github.com/myorg/my-app-config.git \
  --username git \
  --password $GITHUB_TOKEN

Step 6: Deploy with GitOps

Now deployment is as simple as pushing to Git:

# Update the image tag in your config repo
cd my-app-config
sed -i 's/newTag: v1.2.3/newTag: v1.2.4/' apps/production/kustomization.yaml

# Commit and push
git add .
git commit -m "Deploy v1.2.4 to production"
git push origin main

# ArgoCD will automatically detect the change and deploy

Advanced: Rollback and History

View deployment history and rollback:

# View sync history
argocd app history my-app-production

# Rollback to previous version
argocd app rollback my-app-production 2

# Or via Git
git revert HEAD
git push origin main

Advanced: Sync Waves and Hooks

Control deployment order with sync waves:

# Deploy database migration before app
apiVersion: batch/v1
kind: Job
metadata:
  name: db-migration
  annotations:
    argocd.argoproj.io/sync-wave: "-1"  # Run before wave 0
    argocd.argoproj.io/hook: PreSync
spec:
  template:
    spec:
      containers:
      - name: migrate
        image: myorg/migrations:latest
        command: ["./migrate.sh"]
      restartPolicy: Never
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  annotations:
    argocd.argoproj.io/sync-wave: "0"  # Default wave
spec:
  # ...

Integrating with KubeBid Bid Strategies

Combine GitOps with KubeBid's bid strategies for cost-optimized deployments:

# Include bid strategy in your deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-training
  annotations:
    kubebid.io/bid-strategy: cost-optimized
spec:
  replicas: 10
  template:
    spec:
      containers:
      - name: trainer
        image: myorg/trainer:v1
        resources:
          requests:
            nvidia.com/gpu: 1

Best Practices

1. Separate config from code: Keep your Kubernetes manifests in a dedicated repository
2. Use Kustomize or Helm: Don't duplicate YAML across environments
3. Enable auto-sync carefully: Start with manual sync in production, enable auto-sync once confident
4. Set up notifications: Alert on sync failures via Slack/PagerDuty
5. Use ApplicationSets: Manage multiple clusters from a single definition

Next Steps

Now that you have GitOps set up, explore:

• ArgoCD documentation for advanced features
• Bid Strategies to optimize costs
• Progressive delivery with Argo Rollouts