Skip to main content
affpapa.org
RU EN
skill CX Codex

kustomize — Claude Code skill: what it does, how to install

Customizes Kubernetes manifests declaratively without templating. Helps structure base configurations and environment overlays across dev and production.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓ 
npx skills add BagelHole/DevOps-Security-Agent-Skills --skill kustomize -a claude-code
Open on GitHub

What kustomize does

This skill guides the agent in structuring Kubernetes manifests through base files and overlays. It generates kustomization.yaml files and manages ConfigMap resources without template engines.

Manifest modification stays declarative. The agent applies strategic merge patches or JSON patches across environments. Reusable components and remote repository sources work directly.

Inspecting output requires kubectl 1.14+ or the standalone kustomize CLI. Without that tool installed, rendering the final YAML manifests will fail.

What it helps with

  • split Kubernetes manifests into base setups and environment overlays
  • patch container images and replica counts without touching base files
  • generate ConfigMap and Secret resources from configuration files
  • apply JSON patches to remote third-party manifests

Example prompts for the agent

  • Create a base kustomization file with development and production overlays
  • Add a strategic merge patch to update container limits in production
  • Generate a ConfigMap from a config.env file using Kustomize

How to install kustomize

1Skills CLI (Vercel)

npx skills add BagelHole/DevOps-Security-Agent-Skills --skill kustomize -a claude-code

2Manually: put the files in place

~/.claude/skills/kustomize/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/kustomize/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about kustomize

How to install kustomize in Claude Code?

Run npx skills add BagelHole/DevOps-Security-Agent-Skills --skill kustomize -a claude-code. The skill will be added to your agent environment.

What does the kustomize skill do?

It structures Kubernetes configurations through bases and overlays. This lets you patch manifests declaratively without template systems.

What prerequisites are needed?

You need kubectl 1.14+ or the standalone kustomize CLI, along with basic knowledge of Kubernetes manifests.

Source text

SKILL.md · MIT 
---
name: kustomize
description: Customize Kubernetes manifests without templating using Kustomize. Create base configurations with environment overlays, manage configuration variants, and patch resources declaratively. Use when managing Kubernetes configurations across multiple environments without Helm.
license: MIT
metadata:
  author: devops-skills
  version: "1.0"
---

# Kustomize

Customize Kubernetes resources declaratively without templating.

## When to Use This Skill

Use this skill when:
- Managing Kubernetes configs across environments
- Patching existing manifests without modification
- Creating configuration variants from bases
- Customizing third-party manifests
- Preferring declarative over templating approach

## Prerequisites

- kubectl 1.14+ (includes kustomize)
- Or standalone kustomize CLI
- Basic Kubernetes manifest knowledge

## Directory Structure

```
myapp/
├── base/
│   ├── kustomization.yaml
│   ├── deployment.yaml
│   ├── service.yaml
│   └── configmap.yaml
└── overlays/
    ├── development/
    │   ├── kustomization.yaml
    │   └── replica-patch.yaml
    ├── staging/
    │   ├── kustomization.yaml
    │   └── namespace.yaml
    └── production/
        ├── kustomization.yaml
        ├── replica-patch.yaml
        └── resource-patch.yaml
```

## Base Configuration

### kustomization.yaml

```yaml
# base/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - deployment.yaml
  - service.yaml
  - configmap.yaml

commonLabels:
  app: myapp
  
commonAnnotations:
  managed-by: kustomize
```

### Base Resources

```yaml
# base/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "64Mi"
            cpu: "100m"
          limits:
            memory: "128Mi"
            cpu: "200m"
```

## Overlays

### Development Overlay

```yaml
# overlays/development/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - ../../base

namespace: myapp-dev

namePrefix: dev-

commonLabels:
  environment: development

images:
  - name: myapp
    newTag: dev-latest
```

### Production Overlay

```yaml
# overlays/production/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - ../../base

namespace: myapp-prod

namePrefix: prod-

commonLabels:
  environment: production

replicas:
  - name: myapp
    count: 5

images:
  - name: myapp
    newName: registry.example.com/myapp
    newTag: v2.0.0

patches:
  - path: resource-patch.yaml
```

## Patching

### Strategic Merge Patch

```yaml
# overlays/production/resource-patch.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  template:
    spec:
      containers:
      - name: myapp
        resources:
          requests:
            memory: "256Mi"
            cpu: "500m"
          limits:
            memory: "512Mi"
            cpu: "1000m"
```

### JSON Patch

```yaml
# kustomization.yaml
patches:
  - target:
      kind: Deployment
      name: myapp
    patch: |-
      - op: replace
        path: /spec/replicas
        value: 5
      - op: add
        path: /spec/template/spec/containers/0/env
        value:
          - name: LOG_LEVEL
            value: info
```

### Inline Patches

```yaml
# kustomization.yaml
patches:
  - patch: |-
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: myapp
      spec:
        replicas: 3
    target:
      kind: Deployment
      name: myapp
```

## Configuration Generation

### ConfigMap Generator

```yaml
# kustomization.yaml
configMapGenerator:
  - name: myapp-config
    literals:
      - APP_ENV=production
      - LOG_LEVEL=info
    files:
      - config.yaml
    envs:
      - config.env
    options:
      disableNameSuffixHash: false
```

### Secret Generator

```yaml
# kustomization.yaml
secretGenerator:
  - name: myapp-secrets
    literals:
      - api-key=secret123
    files:
      - tls.crt
      - tls.key
    type: kubernetes.io/tls
```

## Image Transformations

```yaml
# kustomization.yaml
images:
  # Change tag
  - name: myapp
    newTag: v2.0.0
  
  # Change registry
  - name: myapp
    newName: registry.example.com/myapp
    newTag: v2.0.0
  
  # Use digest
  - name: myapp
    digest: sha256:abc123...
```

## Resource Transformations

### Name Prefix/Suffix

```yaml
# kustomization.yaml
namePrefix: prod-
nameSuffix: -v2
```

### Namespace

```yaml
# kustomization.yaml
namespace: production
```

### Labels and Annotations

```yaml
# kustomization.yaml
commonLabels:
  app.kubernetes.io/name: myapp
  app.kubernetes.io/environment: production

commonAnnotations:
  example.com/owner: team-a
```

### Replicas

```yaml
# kustomization.yaml
replicas:
  - name: myapp
    count: 5
  - name: worker
    count: 3
```

## Components

```yaml
# components/monitoring/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1alpha1
kind: Component

resources:
  - servicemonitor.yaml

patches:
  - patch: |-
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: myapp
      spec:
        template:
          metadata:
            annotations:
              prometheus.io/scrape: "true"
              prometheus.io/port: "8080"
```

```yaml
# overlays/production/kustomization.yaml
components:
  - ../../components/monitoring
```

## Remote Resources

```yaml
# kustomization.yaml
resources:
  # Remote Git repository
  - https://github.com/org/manifests//base?ref=v1.0.0
  
  # Remote URL
  - https://raw.githubusercontent.com/org/repo/main/deployment.yaml
```

## Commands

```bash
# Build and view output
kubectl kustomize overlays/production

# Apply to cluster
kubectl apply -k overlays/production

# Delete resources
kubectl delete -k overlays/production

# View diff
kubectl diff -k overlays/production

# Build with standalone kustomize
kustomize build overlays/production

# Build and apply
kustomize build overlays/production | kubectl apply -f -
```

## Helm Chart Integration

```yaml
# kustomization.yaml
helmCharts:
  - name: prometheus
    repo: https://prometheus-community.github.io/helm-charts
    version: 25.0.0
    releaseName: prometheus
    namespace: monitoring
    valuesFile: values.yaml
    includeCRDs: true
```

## Variable Substitution

```yaml
# kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - deployment.yaml

replacements:
  - source:
      kind: ConfigMap
      name: myapp-config
      fieldPath: data.APP_VERSION
    targets:
      - select:
          kind: Deployment
          name: myapp
        fieldPaths:
          - spec.template.spec.containers.[name=myapp].image
        options:
          delimiter: ':'
          index: 1
```

## Common Issues

### Issue: Name Hash Conflicts
**Problem**: Resources not updating when ConfigMap changes
**Solution**: Enable name suffix hash (default) or use replacement

### Issue: Patch Not Applying
**Problem**: Strategic merge patch doesn't work
**Solution**: Verify resource names match, use JSON patch for complex changes

### Issue: Remote Resource Fails
**Problem**: Cannot fetch remote resources
**Solution**: Check URL, verify ref/tag exists, ensure network access

### Issue: Label Selector Mismatch
**Problem**: commonLabels breaks selectors
**Solution**: Use includeSelectors: false or exclude specific resources

```yaml
commonLabels:
  app: myapp
configurations:
  - labelExclusions.yaml
```

## Best Practices

- Keep base manifests environment-agnostic
- Use overlays for environment-specific config
- Prefer strategic merge patches for simple changes
- Use components for optional features
- Pin remote resource versions
- Enable ConfigMap/Secret hash suffixes
- Document overlay structure in README
- Test builds before applying

## Related Skills

- [kubernetes-ops](../kubernetes-ops/) - K8s fundamentals
- [helm-charts](../helm-charts/) - Helm alternative
- [argocd-gitops](../argocd-gitops/) - GitOps deployment

© devops-skills · MIT · BagelHole/DevOps-Security-Agent-Skills

Similar skills

Everything for DevOps and infrastructure →
k8s-debug akin-ozer Walks through pod failures, stuck rollouts, DNS and storage problems with kubectl. Useful when a cluster misbehaves right after a deploy. CX Codex +1 819installs kubernetes-skill LukasNiessen Prevents Kubernetes hallucinations when writing manifests, Helm charts, and Kustomize overlays. It diagnoses misconfigurations before deployment. CX Codex +1 1,400installs gitops-repo-audit fluxcd Audits and validates Flux CD GitOps repositories from local files without touching live clusters. Catches schema errors, deprecated APIs, and security gaps. CX Codex +1 662installs helm-chart-scaffolding Seth Hobson This skill helps create and maintain Helm charts for Kubernetes, build reusable templates, and prepare deployments for multiple environments. CX Codex 11,964installs k8s-manifest-generator Seth Hobson This skill generates Kubernetes manifests for application resources and configuration. Use it when you need Deployments, Services, ConfigMaps, Secrets, or PersistentVolumeClaims. CX Codex 11,166installs dt-obs-kubernetes Dynatrace Query and analyze Kubernetes clusters, workload health, OOMKills, and pod placement directly through Dynatrace DQL in your agent. CX Codex +1 2,600installs

From the same set127

audit-logging A skill for setting up centralized audit logging, retention and SIEM forwarding. Useful when you need an action trail for compliance or incident review. CX Codex +1 385installs redis A skill that walks the agent through Redis setup: caching, queues, Sentinel, cluster mode. Useful when a project needs Redis configured. CX Codex +1 379installs penetration-testing Walks your agent through pentest phases: recon, scanning, exploitation, reporting. Useful when you need to validate your own security controls. CX Codex +1 373installs prompt-injection-defense Defends LLM applications against direct and indirect prompt injection attacks. It is designed for securing RAG pipelines and agentic tool-calling workflows. CX Codex +1 372installs disaster-recovery A skill for disaster recovery planning: RTO and RPO targets, replication strategies, failover drills. Useful when you need a continuity plan on paper. CX Codex +1 367installs kubernetes-hardening Generates hardened Kubernetes manifests with strict security contexts, network policies, and RBAC rules. Useful when preparing workloads for security compliance. CX Codex +1 366installs git-workflow A skill that lays out branching strategies, pull request flow and release management so a team settles on one set of Git rules. CX Codex +1 367installs cis-benchmarks Audits systems against CIS benchmarks and helps remediate security violations. Useful for applying hardening baselines to Linux servers or Kubernetes nodes. CX Codex +1 366installs

Project sponsors

Companies that keep this analytics open
Gold sponsor
Nutra.Club

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor