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

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