devops-automation · rohitg00 — Claude Code skill: CI/CD and setup
The devops-automation skill guides CI/CD design for GitHub Actions and configuration work with Docker, Kubernetes, Helm, and ArgoCD. Use it when planning an application build and deployment flow.
Apache-2.0 ★ 2,858 updated 2026-05-12
npx skills add rohitg00/awesome-claude-code-toolkit --skill devops-automation -a claude-codeWhat devops-automation does
The skill lays out a GitHub Actions pipeline with separate lint, test, and deploy jobs, a Node.js version matrix, dependency caching, and deployment conditions. Its Docker guidance uses a multi-stage build, runs the final container as a non-root user, and adds a health check.
For Kubernetes, it includes a Deployment manifest with resource requests and probes, a Helm chart layout, and an ArgoCD Application example that syncs cluster state from Git. A Prometheus ServiceMonitor example accompanies advice on metrics, alerts, and secret storage. Check the examples against your project: the Dockerfile starts dist/server.js, while the Kubernetes manifest refers to a secret named api-secrets.
The skill recommends validating charts with helm lint and helm template, and pinning GitHub Actions versions by SHA. These snippets need project-specific edits; names, secrets, and deployment commands are examples, not a drop-in configuration.
What it helps with
- split GitHub Actions into lint, test, and deploy jobs
- build a multi-stage Dockerfile for a Node.js app
- add resource settings and health probes to a Kubernetes Deployment
- organize Helm values for separate environments
- sync Kubernetes manifests from Git with ArgoCD
Example prompts for the agent
- Design GitHub Actions for my app with linting, tests, and a deploy from
main. - Write a multi-stage Dockerfile for this Node.js app and run the container as a non-root user.
- Create a Helm chart and an ArgoCD manifest that syncs the app from Git.
How to install devops-automation
1Skills CLI (Vercel)
npx skills add rohitg00/awesome-claude-code-toolkit --skill devops-automation -a claude-code2Manually: put the files in place
~/.claude/skills/devops-automation/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/devops-automation/
1Skills CLI (Vercel)
npx skills add rohitg00/awesome-claude-code-toolkit --skill devops-automation -a codex2Manually: put the files in place
.agents/skills/devops-automation/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add rohitg00/awesome-claude-code-toolkit --skill devops-automation -a cursor2Manually: put the files in place
.cursor/skills/devops-automation/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install rohitg00/awesome-claude-code-toolkit skills/devops-automation2Manually: put the files in place
.github/skills/devops-automation/SKILL.md1Skills CLI (Vercel)
npx skills add rohitg00/awesome-claude-code-toolkit --skill devops-automation -a gemini-cli2Platform CLI
gemini skills install https://github.com/rohitg00/awesome-claude-code-toolkit --path skills/devops-automationManually: put the files in place
.devin/skills/devops-automation/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about devops-automation
How do I install devops-automation in Claude Code?
Run npx skills add rohitg00/awesome-claude-code-toolkit --skill devops-automation -a claude-code. The skill file is at ~/.claude/skills/devops-automation/SKILL.md.
What does the devops-automation skill do?
It guides CI/CD pipeline design and configuration for Docker, Kubernetes, Helm, and ArgoCD. It also covers monitoring and pipeline security practices.
How does devops-automation suggest checking a Helm chart?
Run helm lint to check the chart, then use helm template to inspect the rendered manifests before deployment.
Source text
SKILL.md · Apache-2.0
---
name: devops-automation
description: CI/CD pipeline design with GitHub Actions, Docker, Kubernetes, Helm, and GitOps patterns
---
# DevOps Automation
## GitHub Actions Workflow Structure
```yaml
name: CI/CD
on:
push:
branches: [main]
pull_request:
branches: [main]
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
jobs:
lint:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 22
cache: 'npm'
- run: npm ci
- run: npm run lint
test:
runs-on: ubuntu-latest
needs: lint
strategy:
matrix:
node-version: [20, 22]
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: ${{ matrix.node-version }}
cache: 'npm'
- run: npm ci
- run: npm test -- --coverage
- uses: actions/upload-artifact@v4
with:
name: coverage-${{ matrix.node-version }}
path: coverage/
deploy:
runs-on: ubuntu-latest
needs: test
if: github.ref == 'refs/heads/main'
environment: production
steps:
- uses: actions/checkout@v4
- run: ./deploy.sh
```
Key patterns:
- Use `concurrency` to cancel outdated runs
- Cache dependencies with setup action's `cache` option
- Use `needs` for job dependencies
- Gate deploys with `environment` protection rules
- Use matrix for cross-version testing
## Docker Multi-Stage Builds
```dockerfile
FROM node:22-alpine AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --production
FROM node:22-alpine AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build
FROM node:22-alpine AS runner
WORKDIR /app
RUN addgroup -g 1001 appgroup && adduser -u 1001 -G appgroup -S appuser
COPY --from=deps /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package.json ./
USER appuser
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=3s CMD wget -qO- http://localhost:3000/health || exit 1
CMD ["node", "dist/server.js"]
```
Rules:
- Use specific image tags, never `latest`
- Run as non-root user
- Copy only necessary files into final stage
- Add `HEALTHCHECK` for orchestrator integration
- Use `.dockerignore` to exclude `node_modules`, `.git`, tests
## Kubernetes Deployment Manifest
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: api-server
labels:
app: api-server
spec:
replicas: 3
selector:
matchLabels:
app: api-server
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1
maxUnavailable: 0
template:
metadata:
labels:
app: api-server
spec:
containers:
- name: api
image: registry.example.com/api:v1.2.3
ports:
- containerPort: 3000
resources:
requests:
cpu: 100m
memory: 128Mi
limits:
cpu: 500m
memory: 512Mi
readinessProbe:
httpGet:
path: /health
port: 3000
initialDelaySeconds: 5
periodSeconds: 10
livenessProbe:
httpGet:
path: /health
port: 3000
initialDelaySeconds: 15
periodSeconds: 20
env:
- name: DATABASE_URL
valueFrom:
secretKeyRef:
name: api-secrets
key: database-url
```
Always set resource requests and limits. Always define readiness and liveness probes. Use `maxUnavailable: 0` for zero-downtime deploys.
## Helm Chart Structure
```
chart/
Chart.yaml
values.yaml
values-staging.yaml
values-production.yaml
templates/
deployment.yaml
service.yaml
ingress.yaml
hpa.yaml
_helpers.tpl
```
```yaml
# values.yaml
replicaCount: 2
image:
repository: registry.example.com/api
tag: latest
pullPolicy: IfNotPresent
resources:
requests:
cpu: 100m
memory: 128Mi
limits:
cpu: 500m
memory: 512Mi
ingress:
enabled: true
host: api.example.com
autoscaling:
enabled: true
minReplicas: 2
maxReplicas: 10
targetCPUUtilization: 70
```
Use `values-{env}.yaml` overrides per environment. Lint charts with `helm lint`. Test with `helm template` before deploying.
## ArgoCD GitOps Pattern
```yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: api-server
namespace: argocd
spec:
project: default
source:
repoURL: https://github.com/org/k8s-manifests
targetRevision: main
path: apps/api-server
destination:
server: https://kubernetes.default.svc
namespace: production
syncPolicy:
automated:
prune: true
selfHeal: true
syncOptions:
- CreateNamespace=true
```
GitOps principles:
- Git is the single source of truth for cluster state
- All changes go through PRs (no `kubectl apply` in production)
- ArgoCD auto-syncs from Git to cluster
- Enable `selfHeal` to revert manual cluster changes
- Separate app code repos from deployment manifest repos
## Monitoring Stack
```yaml
# Prometheus ServiceMonitor
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
name: api-server
spec:
selector:
matchLabels:
app: api-server
endpoints:
- port: metrics
interval: 15s
path: /metrics
```
Key metrics to expose:
- `http_request_duration_seconds` (histogram) - request latency by route and status
- `http_requests_total` (counter) - request count by route and status
- `process_resident_memory_bytes` (gauge) - memory usage
- `db_query_duration_seconds` (histogram) - database query latency
Alert on: error rate >1%, P99 latency >2s, memory >80% of limit, pod restarts >3 in 10 minutes.
## Pipeline Best Practices
1. Keep CI under 10 minutes (parallelize jobs, cache aggressively)
2. Run linting and type checking before tests
3. Use ephemeral environments for PR previews
4. Pin all action versions to SHA, not tags
5. Store secrets in GitHub Secrets, never in workflow files
6. Use OIDC for cloud provider authentication (no long-lived keys)
7. Tag images with git SHA, not `latest`
8. Run security scans (Trivy, Snyk) on container images in CI
© rohitg00 · Apache-2.0 · rohitg00/awesome-claude-code-toolkit
Similar skills
All skills for DevOps and infrastructure →devops-automation by other authors comes first.