home / skills / jeremylongshore / claude-code-plugins-plus-skills / building-gitops-workflows

This skill helps you build production-ready GitOps workflows with ArgoCD or Flux, generating manifests and secure deployment configurations.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill building-gitops-workflows

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
3.5 KB
---
name: building-gitops-workflows
description: |
  Execute use when constructing GitOps workflows using ArgoCD or Flux. Trigger with phrases like "create GitOps workflow", "setup ArgoCD", "configure Flux", or "automate Kubernetes deployments". Generates production-ready configurations, implements best practices, and ensures security-first approach for continuous deployment.
allowed-tools: Read, Write, Edit, Grep, Glob, Bash(kubectl:*), Bash(git:*)
version: 1.0.0
author: Jeremy Longshore <[email protected]>
license: MIT
---
# Gitops Workflow Builder

This skill provides automated assistance for gitops workflow builder tasks.

## Prerequisites

Before using this skill, ensure:
- Kubernetes cluster is accessible and kubectl is configured
- Git repository is available for GitOps source
- ArgoCD or Flux is installed on the cluster (or ready to install)
- Appropriate RBAC permissions for GitOps operator
- Network connectivity between cluster and Git repository

## Instructions

1. **Select GitOps Tool**: Determine whether to use ArgoCD or Flux based on requirements
2. **Define Application Structure**: Establish repository layout with environment separation (dev/staging/prod)
3. **Generate Manifests**: Create Application/Kustomization files pointing to Git sources
4. **Configure Sync Policy**: Set automated or manual sync with self-heal and prune options
5. **Implement RBAC**: Define service accounts and role bindings for GitOps operator
6. **Set Up Monitoring**: Configure notifications and health checks for deployments
7. **Validate Configuration**: Test sync behavior and verify reconciliation loops

## Output

Generates GitOps workflow configurations including:

**ArgoCD Application Manifest:**
```yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: app-name
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/org/repo
    path: manifests/prod
    targetRevision: main
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
```

**Flux Kustomization:**
```yaml
apiVersion: kustomize.toolkit.fluxcd.io/v1
kind: Kustomization
metadata:
  name: app-name
  namespace: flux-system
spec:
  interval: 5m
  path: ./manifests/prod
  prune: true
  sourceRef:
    kind: GitRepository
    name: app-repo
```

## Error Handling

Common issues and solutions:

**Sync Failures**
- Error: "ComparisonError: Failed to load target state"
- Solution: Verify Git repository URL, credentials, and target path exist

**RBAC Permissions**
- Error: "User cannot create resource in API group"
- Solution: Grant GitOps service account appropriate cluster roles

**Out of Sync State**
- Warning: "Application is OutOfSync"
- Solution: Enable automated sync or manually sync via UI/CLI

**Git Authentication**
- Error: "Authentication failed for repository"
- Solution: Configure SSH keys or access tokens in {baseDir}/.git/config

**Resource Conflicts**
- Error: "Resource already exists and is not managed by GitOps"
- Solution: Import existing resources or remove conflicting manual deployments

## Resources

- ArgoCD documentation: https://argo-cd.readthedocs.io/
- Flux documentation: https://fluxcd.io/docs/
- GitOps principles and patterns guide
- Kubernetes manifest best practices
- Repository structure templates in {baseDir}/gitops-examples/

## Overview

This skill provides automated assistance for the described functionality.

## Examples

Example usage patterns will be demonstrated in context.

Overview

This skill helps construct secure, production-ready GitOps workflows for Kubernetes using ArgoCD or Flux. It generates manifests, sync policies, RBAC, and monitoring hooks tailored to environment layouts (dev/staging/prod). Use it to automate deployments with a security-first posture and repeatable repository structures.

How this skill works

Provide the target cluster, Git repository, chosen GitOps operator (ArgoCD or Flux), and desired environment layout. The skill generates Application/Kustomization manifests, service account and role bindings, sync policy settings (automated/manual, prune, selfHeal), and monitoring/notification stubs. It also validates common failure modes (auth, RBAC, path errors) and offers remediation suggestions.

When to use it

  • Setting up GitOps for a new application or environment (dev/staging/prod)
  • Migrating manual Kubernetes deployments into a declarative GitOps flow
  • Bootstrapping ArgoCD or Flux manifests and repository layout templates
  • Implementing automated sync with pruning and self-heal in production
  • Hardening GitOps operator access and RBAC for secure deployments

Best practices

  • Separate repositories or directories by environment and enforce branch protections
  • Use automated sync with prune and selfHeal for immutable, reproducible deployments
  • Create least-privilege service accounts and cluster roles for the GitOps operator
  • Store Git credentials securely (SSH keys or scoped tokens) and test access from the cluster
  • Include health checks, alerts, and deployment previews before enabling auto-sync

Example use cases

  • Generate an ArgoCD Application manifest pointing to manifests/prod with automated sync and pruning
  • Create Flux Kustomization resources and a GitRepository source for continuous reconciliations
  • Produce RBAC manifests for a GitOps service account with only the necessary permissions
  • Troubleshoot sync failures by validating repo URL, path, and revision and suggesting fixes
  • Bootstrap a repo layout with overlays for dev, staging, and production and sample Kustomize files

FAQ

What do I need before running this skill?

A reachable Kubernetes cluster with kubectl configured, a Git repository for manifests, and permissions to install or configure ArgoCD/Flux.

Which tool should I choose, ArgoCD or Flux?

Choose ArgoCD for a UI-driven multi-cluster workflow and Flux for Git-native, controller-based reconciliation; pick based on team preference and integration needs.

How does it handle Git authentication?

It recommends and templates SSH key or token-based credentials and points to secure storage mechanisms; you must provision the credential in the cluster or secret store.