playbooks

home / skills / openclaw / skills / k8s-gen

k8s-gen skill

/skills/lxgicstudios/k8s-gen

This skill generates production-ready Kubernetes manifests from docker-compose or plain descriptions to simplify deploying apps to Kubernetes.

npx playbooks add skill openclaw/skills --skill k8s-gen

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

Files (8)
SKILL.md
2.4 KB
---
name: k8s-gen
description: Generate Kubernetes manifests from docker-compose or plain English. Use when deploying apps to K8s.
---

# Kubernetes Manifest Generator

Stop writing YAML by hand. This tool converts your docker-compose files or plain descriptions into production ready Kubernetes manifests. Deployments, Services, ConfigMaps, the whole thing.

**One command. Zero config. Just works.**

## Quick Start

```bash
npx ai-k8s "nginx with 3 replicas, exposed on port 80"
```

## What It Does

- Converts docker-compose.yml to Kubernetes manifests automatically
- Generates Deployments, Services, ConfigMaps, and Secrets
- Creates proper resource limits and health checks
- Outputs clean, production ready YAML you can kubectl apply
- Handles multi-service architectures with proper networking

## Usage Examples

```bash
# Generate from a description
npx ai-k8s "postgres database with persistent volume"

# Convert docker-compose to K8s
npx ai-k8s --compose docker-compose.yml

# Full app stack
npx ai-k8s "node app with redis cache and postgres db, 3 replicas each"
```

## Best Practices

- **Start simple** - Generate one service first, validate it works, then add complexity
- **Review resource limits** - The AI sets reasonable defaults, but adjust for your workload
- **Use namespaces** - Add --namespace flag to keep your deployments organized
- **Version your manifests** - Commit generated YAML to git, treat it as code

## When to Use This

- You know Docker but K8s YAML feels overwhelming
- Migrating docker-compose setups to Kubernetes
- Prototyping new deployments quickly without YAML boilerplate
- Learning K8s concepts through generated examples

## Part of the LXGIC Dev Toolkit

This is one of 110+ free developer tools built by LXGIC Studios. No paywalls, no sign-ups, no API keys on free tiers. Just tools that work.

**Find more:**
- GitHub: https://github.com/LXGIC-Studios
- Twitter: https://x.com/lxgicstudios
- Substack: https://lxgicstudios.substack.com
- Website: https://lxgic.dev

## Requirements

No install needed. Just run with npx. Node.js 18+ recommended.

```bash
npx ai-k8s --help
```

## How It Works

The tool analyzes your docker-compose file or description, understands the services and their relationships, then generates idiomatic Kubernetes manifests. It maps Docker concepts to K8s equivalents like volumes to PersistentVolumeClaims and ports to Services.

## License

MIT. Free forever. Use it however you want.

Overview

This skill generates Kubernetes manifests from docker-compose files or plain English descriptions. It produces production-ready YAML for Deployments, Services, ConfigMaps, Secrets, and PersistentVolumeClaims so you can kubectl apply immediately. No extra configuration is required — one command to convert and deploy.

How this skill works

The tool parses a docker-compose.yml or interprets a natural-language app description to identify services, ports, volumes, and dependencies. It maps Docker concepts to Kubernetes primitives, adds resource limits and health checks, and outputs clean, idiomatic YAML for multi-service architectures. The result is a set of manifests ready to be organized by namespace and versioned in git.

When to use it

  • Migrating a docker-compose setup to Kubernetes
  • Prototyping a Kubernetes deployment quickly without hand-writing YAML
  • Generating examples to learn K8s resources and relationships
  • Converting a plain-English app spec into K8s manifests
  • Preparing manifests to commit into your infrastructure-as-code repo

Best practices

  • Start by generating a single service and validate it in a cluster before scaling to multi-service stacks
  • Review and tune automatically assigned resource limits and probes to match real workload needs
  • Use namespaces and labels to organize generated manifests for environments and teams
  • Commit generated YAML to source control and treat it as code with reviews and versioning
  • Add secret management tooling for sensitive data rather than relying on generated plain Secrets

Example use cases

  • Convert a docker-compose file for a Node.js + Redis + Postgres app into Deployments, Services, and PVCs
  • Generate a production-ready nginx Deployment with 3 replicas and a Service exposed on port 80 from a short description
  • Create ConfigMaps and Secrets from environment variables described in compose or text
  • Produce health checks and resource requests/limits automatically for a multi-service stack
  • Iterate on architecture quickly by editing the plain-English spec and regenerating manifests

FAQ

Do I need to install anything to use this skill?

No installation is required; run it with npx and Node.js 18+ is recommended.

Are the generated manifests safe to deploy to production as-is?

They are production-oriented and include probes and limits, but you should review and adjust resource sizing, secrets handling, and any environment-specific settings before deploying to production.