AutoGineer
Generated banner for Gitops Workflow
Generated logo for Gitops Workflow

Gitops Workflow

Seth HobsonCommunityCreated by Seth Hobson

  • Skill
  • Tool integration
  • Cloud and DevOps
  • MIT
  • No issues found
Download ZIP

From the author

Implement GitOps workflows with ArgoCD and Flux for automated, declarative Kubernetes deployments with continuous reconciliation. Use when implementing GitOps practices, automating Kubernetes deployments, or setting up declarative infrastructure management.
— the description by Seth Hobson

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a comprehensive guide for establishing GitOps practices on Kubernetes clusters. It covers the installation, configuration, and management of ArgoCD and Flux CD to achieve declarative, versioned, and continuously reconciled infrastructure and application deployments. The content includes setup instructions, repository structure patterns, sync policy configurations, and strategies for managing secrets and progressive delivery.

What it does

  • Provides installation steps for ArgoCD and Flux CD on Kubernetes.
  • Defines GitOps repository structures and the App of Apps pattern.
  • Configures automated sync policies and reconciliation intervals.
  • Demonstrates secret management using External Secrets and Sealed Secrets.
  • Outlines progressive delivery strategies like Canary and Blue-Green deployments.
  • Offers troubleshooting commands for sync failures and status checks.

When to use it

  • When setting up GitOps practices for Kubernetes clusters.
  • When automating application deployments directly from Git repositories.
  • When managing multi-cluster environments declaratively.
  • When configuring automated reconciliation for infrastructure state.
  • When implementing progressive delivery strategies for application updates.

Advantages

  • Enables version-controlled and immutable infrastructure state.
  • Supports continuous reconciliation between Git and cluster state.
  • Facilitates automated deployment and pruning of resources.
  • Provides flexible sync options and retry mechanisms.
  • Allows for standardized secret management integration.

Usage examples

“How do I install ArgoCD on my Kubernetes cluster?”
The skill provides kubectl commands to create the argocd namespace and apply the installation manifests, followed by instructions to retrieve the initial admin password.
“How can I configure an automated sync policy for my application in ArgoCD?”
The skill provides a YAML configuration example for the Application resource, including automated sync, pruning, and self-healing settings.
“What is the command to bootstrap Flux CD?”
The skill provides the flux bootstrap command for GitHub, including parameters for owner, repository, branch, and path.
“How do I perform a canary deployment with ArgoCD?”
The skill provides a Rollout resource example demonstrating how to define canary steps with weight adjustments and pauses.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/wshobson/gitops-workflow/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip gitops-workflow.zip -d .agents/skills

Documentation by Seth Hobson

GitOps Workflow

Complete guide to implementing GitOps workflows with ArgoCD and Flux for automated Kubernetes deployments.

Purpose

Implement declarative, Git-based continuous delivery for Kubernetes using ArgoCD or Flux CD, following OpenGitOps principles.

When to Use This Skill

  • Set up GitOps for Kubernetes clusters

  • Automate application deployments from Git

  • Implement progressive delivery strategies

  • Manage multi-cluster deployments

  • Configure automated sync policies

  • Set up secret management in GitOps

OpenGitOps Principles

  1. Declarative - Entire system described declaratively

  2. Versioned and Immutable - Desired state stored in Git

  3. Pulled Automatically - Software agents pull desired state

  4. Continuously Reconciled - Agents reconcile actual vs desired state

ArgoCD Setup

1. 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

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

Reference: See references/argocd-setup.md for detailed setup

2. Repository Structure
gitops-repo/
├── apps/
│   ├── production/
│   │   ├── app1/
│   │   │   ├── kustomization.yaml
│   │   │   └── deployment.yaml
│   │   └── app2/
│   └── staging/
├── infrastructure/
│   ├── ingress-nginx/
│   ├── cert-manager/
│   └── monitoring/
└── argocd/
    ├── applications/
    └── projects/
3. Create Application
# argocd/applications/my-app.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/org/gitops-repo
    targetRevision: main
    path: apps/production/my-app
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true
4. App of Apps Pattern
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: applications
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/org/gitops-repo
    targetRevision: main
    path: argocd/applications
  destination:
    server: https://kubernetes.default.svc
    namespace: argocd
  syncPolicy:
    automated: {}

Flux CD Setup

1. Installation

The example uses Homebrew. For other systems, follow the official Flux installation guide.

# Install the Flux CLI with Homebrew
brew install fluxcd/tap/flux
flux check --pre

# Bootstrap Flux
flux bootstrap github \
  --owner=org \
  --repository=gitops-repo \
  --branch=main \
  --path=clusters/production \
  --personal
2. Create GitRepository
apiVersion: source.toolkit.fluxcd.io/v1
kind: GitRepository
metadata:
  name: my-app
  namespace: flux-system
spec:
  interval: 1m
  url: https://github.com/org/my-app
  ref:
    branch: main
3. Create Kustomization
apiVersion: kustomize.toolkit.fluxcd.io/v1
kind: Kustomization
metadata:
  name: my-app
  namespace: flux-system
spec:
  interval: 5m
  path: ./deploy
  prune: true
  sourceRef:
    kind: GitRepository
    name: my-app

Sync Policies

Auto-Sync Configuration

ArgoCD:

syncPolicy:
  automated:
    prune: true # Delete resources not in Git
    selfHeal: true # Reconcile manual changes
    allowEmpty: false
  retry:
    limit: 5
    backoff:
      duration: 5s
      factor: 2
      maxDuration: 3m

Flux:

spec:
  interval: 1m
  prune: true
  wait: true
  timeout: 5m

Reference: See references/sync-policies.md

Progressive Delivery

Canary Deployment with ArgoCD Rollouts
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: my-app
spec:
  replicas: 5
  strategy:
    canary:
      steps:
        - setWeight: 20
        - pause: { duration: 1m }
        - setWeight: 50
        - pause: { duration: 2m }
        - setWeight: 100
Blue-Green Deployment
strategy:
  blueGreen:
    activeService: my-app
    previewService: my-app-preview
    autoPromotionEnabled: false

Secret Management

External Secrets Operator
apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: db-credentials
spec:
  refreshInterval: 1h
  secretStoreRef:
    name: aws-secrets-manager
    kind: SecretStore
  target:
    name: db-credentials
  data:
    - secretKey: password
      remoteRef:
        key: prod/db/password
Sealed Secrets
# Encrypt secret
kubeseal --format yaml < secret.yaml > sealed-secret.yaml

# Commit sealed-secret.yaml to Git

Best Practices

  1. Use separate repos or branches for different environments

  2. Implement RBAC for Git repositories

  3. Enable notifications for sync failures

  4. Use health checks for custom resources

  5. Implement approval gates for production

  6. Keep secrets out of Git (use External Secrets)

  7. Use App of Apps pattern for organization

  8. Tag releases for easy rollback

  9. Monitor sync status with alerts

  10. Test changes in staging first

Troubleshooting

Sync failures:

argocd app get my-app
argocd app sync my-app --prune

Out of sync status:

argocd app diff my-app
argocd app sync my-app --force

Related Skills

  • k8s-manifest-generator - For creating manifests

  • helm-chart-scaffolding - For packaging applications

Files

references/argocd-setup.md

ArgoCD Setup and Configuration

Installation Methods

1. Standard Installation
kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
2. High Availability Installation
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/ha/install.yaml
3. Helm Installation
helm repo add argo https://argoproj.github.io/argo-helm
helm install argocd argo/argo-cd -n argocd --create-namespace

Initial Configuration

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

# Get initial admin password
argocd admin initial-password -n argocd
Configure Ingress
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: argocd-server-ingress
  namespace: argocd
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
spec:
  ingressClassName: nginx
  rules:
    - host: argocd.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: argocd-server
                port:
                  number: 443
  tls:
    - hosts:
        - argocd.example.com
      secretName: argocd-secret

CLI Configuration

Login
argocd login argocd.example.com --username admin
Add Repository
argocd repo add https://github.com/org/repo --username user --password token
Create Application
argocd app create my-app \
  --repo https://github.com/org/repo \
  --path apps/my-app \
  --dest-server https://kubernetes.default.svc \
  --dest-namespace production

SSO Configuration

GitHub OAuth
apiVersion: v1
kind: ConfigMap
metadata:
  name: argocd-cm
  namespace: argocd
data:
  url: https://argocd.example.com
  dex.config: |
    connectors:
      - type: github
        id: github
        name: GitHub
        config:
          clientID: $GITHUB_CLIENT_ID
          clientSecret: $GITHUB_CLIENT_SECRET
          orgs:
          - name: my-org

RBAC Configuration

apiVersion: v1
kind: ConfigMap
metadata:
  name: argocd-rbac-cm
  namespace: argocd
data:
  policy.default: role:readonly
  policy.csv: |
    p, role:developers, applications, *, */dev, allow
    p, role:operators, applications, *, */*, allow
    g, my-org:devs, role:developers
    g, my-org:ops, role:operators

Best Practices

  1. Enable SSO for production

  2. Implement RBAC policies

  3. Use separate projects for teams

  4. Enable audit logging

  5. Configure notifications

  6. Use ApplicationSets for multi-cluster

  7. Implement resource hooks

  8. Configure health checks

  9. Use sync windows for maintenance

  10. Monitor with Prometheus metrics

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs a command-line tool

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Seth Hobson
Publisher
Seth Hobson (Community)
Source
wshobson/agents · plugins/kubernetes-operations/skills/gitops-workflow · commit 4bde316
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Seth Hobson or Seth Hobson.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download gitops-workflow.zip