kubernetes-deployment
Kubernetes deployment workflow for container orchestration, Helm charts, service mesh, and production-ready K8s configurations.
About this skill
This AI agent skill provides a comprehensive, multi-phase workflow for automating the deployment of applications to Kubernetes clusters. It covers critical aspects of modern container orchestration, including intelligent container preparation leveraging prerequisite skills like `docker-expert`, automated Helm chart generation for standardized and repeatable deployments, and meticulous configuration of service meshes (e.g., Istio, Linkerd) to manage traffic, security, and observability. Furthermore, the skill incorporates production-ready Kubernetes patterns, ensuring robust networking configurations, strong security policies, and optimized resource management. It streamlines the path to reliable, scalable, and secure application deployments by guiding the AI agent through each necessary step from containerization to full cluster integration.
Best use case
Automating the deployment of containerized applications to Kubernetes, standardizing Helm chart creation across projects, configuring service mesh capabilities for microservices, and ensuring K8s deployments adhere to production-grade security and networking best practices.
Kubernetes deployment workflow for container orchestration, Helm charts, service mesh, and production-ready K8s configurations.
A successfully deployed application on a Kubernetes cluster, packaged with a generated Helm chart, with its service mesh fully configured, and adhering to specified production-ready K8s networking and security patterns. The agent will confirm the deployment status and provide relevant details.
Practical example
Example input
Deploy the 'user-management-api' application to our 'production-eu' Kubernetes cluster. The Docker image is `myregistry.com/org/user-management-api:v2.1.0`. Generate a new Helm chart for it, ensuring high availability with 3 replicas, and configure it to integrate with the existing Istio service mesh for mutual TLS and traffic routing.
Example output
```json
{
"status": "success",
"message": "Application 'user-management-api' successfully deployed to 'production-eu' cluster.",
"details": {
"application_name": "user-management-api",
"cluster_name": "production-eu",
"docker_image": "myregistry.com/org/user-management-api:v2.1.0",
"helm_chart_generated": "user-management-api-2.1.0.tgz",
"helm_release_name": "user-management-api-prod",
"kubernetes_namespace": "user-management",
"replicas_configured": 3,
"service_mesh_configured": "Istio (mTLS enabled, traffic rules applied)",
"deployment_url": "https://k8s-dashboard.prod-eu.example.com/deployments/user-management-api-prod",
"k8s_manifests_storage": "s3://k8s-configs/user-management-api/v2.1.0/manifests.zip",
"next_steps": "Verify health checks and monitor service logs via Prometheus/Grafana."
}
}
```When to use this skill
- When deploying new applications or updates to a Kubernetes cluster.
- When generating or updating Helm charts for application packaging and deployment.
- When configuring or modifying service mesh settings (e.g., Istio, Linkerd) for traffic management, observability, or security.
- When setting up or verifying Kubernetes networking configurations.
When not to use this skill
- When deploying applications to non-Kubernetes environments (e.g., bare metal, serverless, traditional VMs).
- For very simple, local deployments where advanced container orchestration, Helm, or service mesh are not required.
- When you need to perform actions *outside* the scope of Kubernetes deployment (e.g., source code analysis, database administration).
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/kubernetes-deployment/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How kubernetes-deployment Compares
| Feature / Agent | kubernetes-deployment | Standard Approach |
|---|---|---|
| Platform Support | Claude | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | medium | N/A |
Frequently Asked Questions
What does this skill do?
Kubernetes deployment workflow for container orchestration, Helm charts, service mesh, and production-ready K8s configurations.
Which AI agents support this skill?
This skill is designed for Claude.
How difficult is it to install?
The installation complexity is rated as medium. You can find the installation instructions above.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
Top AI Agents for Productivity
See the top AI agent skills for productivity, workflow automation, operational systems, documentation, and everyday task execution.
Cursor vs Codex for AI Workflows
Compare Cursor and Codex for AI coding workflows, repository assistance, debugging, refactoring, and reusable developer skills.
SKILL.md Source
# Kubernetes Deployment Workflow ## Overview Specialized workflow for deploying applications to Kubernetes including container orchestration, Helm charts, service mesh configuration, and production-ready K8s patterns. ## When to Use This Workflow Use this workflow when: - Deploying to Kubernetes - Creating Helm charts - Configuring service mesh - Setting up K8s networking - Implementing K8s security ## Workflow Phases ### Phase 1: Container Preparation #### Skills to Invoke - `docker-expert` - Docker containerization - `k8s-manifest-generator` - K8s manifests #### Actions 1. Create Dockerfile 2. Build container image 3. Optimize image size 4. Push to registry 5. Test container #### Copy-Paste Prompts ``` Use @docker-expert to containerize application for K8s ``` ### Phase 2: K8s Manifests #### Skills to Invoke - `k8s-manifest-generator` - Manifest generation - `kubernetes-architect` - K8s architecture #### Actions 1. Create Deployment 2. Configure Service 3. Set up ConfigMap 4. Create Secrets 5. Add Ingress #### Copy-Paste Prompts ``` Use @k8s-manifest-generator to create K8s manifests ``` ### Phase 3: Helm Chart #### Skills to Invoke - `helm-chart-scaffolding` - Helm charts #### Actions 1. Create chart structure 2. Define values.yaml 3. Add templates 4. Configure dependencies 5. Test chart #### Copy-Paste Prompts ``` Use @helm-chart-scaffolding to create Helm chart ``` ### Phase 4: Service Mesh #### Skills to Invoke - `istio-traffic-management` - Istio - `linkerd-patterns` - Linkerd - `service-mesh-expert` - Service mesh #### Actions 1. Choose service mesh 2. Install mesh 3. Configure traffic management 4. Set up mTLS 5. Add observability #### Copy-Paste Prompts ``` Use @istio-traffic-management to configure Istio ``` ### Phase 5: Security #### Skills to Invoke - `k8s-security-policies` - K8s security - `mtls-configuration` - mTLS #### Actions 1. Configure RBAC 2. Set up NetworkPolicy 3. Enable PodSecurity 4. Configure secrets 5. Implement mTLS #### Copy-Paste Prompts ``` Use @k8s-security-policies to secure Kubernetes cluster ``` ### Phase 6: Observability #### Skills to Invoke - `grafana-dashboards` - Grafana - `prometheus-configuration` - Prometheus #### Actions 1. Install monitoring stack 2. Configure Prometheus 3. Create Grafana dashboards 4. Set up alerts 5. Add distributed tracing #### Copy-Paste Prompts ``` Use @prometheus-configuration to set up K8s monitoring ``` ### Phase 7: Deployment #### Skills to Invoke - `deployment-engineer` - Deployment - `gitops-workflow` - GitOps #### Actions 1. Configure CI/CD 2. Set up GitOps 3. Deploy to cluster 4. Verify deployment 5. Monitor rollout #### Copy-Paste Prompts ``` Use @gitops-workflow to implement GitOps deployment ``` ## Quality Gates - [ ] Containers working - [ ] Manifests valid - [ ] Helm chart installs - [ ] Security configured - [ ] Monitoring active - [ ] Deployment successful ## Related Workflow Bundles - `cloud-devops` - Cloud/DevOps - `terraform-infrastructure` - Infrastructure - `docker-containerization` - Containers
Related Skills
deployment-procedures
Production deployment principles and decision-making. Safe deployment workflows, rollback strategies, and verification. Teaches thinking, not scripts.
deployment-pipeline-design
Architecture patterns for multi-stage CI/CD pipelines with approval gates and deployment strategies.
linux-shell-scripting
Provide production-ready shell script templates for common Linux system administration tasks including backups, monitoring, user management, log analysis, and automation. These scripts serve as building blocks for security operations and penetration testing environments.
iterate-pr
Iterate on a PR until CI passes. Use when you need to fix CI failures, address review feedback, or continuously push fixes until all checks are green. Automates the feedback-fix-push-wait cycle.
istio-traffic-management
Comprehensive guide to Istio traffic management for production service mesh deployments.
incident-runbook-templates
Production-ready templates for incident response runbooks covering detection, triage, mitigation, resolution, and communication.
incident-response-smart-fix
[Extended thinking: This workflow implements a sophisticated debugging and resolution pipeline that leverages AI-assisted debugging tools and observability platforms to systematically diagnose and res
incident-responder
Expert SRE incident responder specializing in rapid problem resolution, modern observability, and comprehensive incident management.
expo-cicd-workflows
Helps understand and write EAS workflow YAML files for Expo projects. Use this skill when the user asks about CI/CD or workflows in an Expo or EAS context, mentions .eas/workflows/, or wants help with EAS build pipelines or deployment automation.
error-diagnostics-error-trace
You are an error tracking and observability expert specializing in implementing comprehensive error monitoring solutions. Set up error tracking systems, configure alerts, implement structured logging,
error-debugging-error-trace
You are an error tracking and observability expert specializing in implementing comprehensive error monitoring solutions. Set up error tracking systems, configure alerts, implement structured logging, and ensure teams can quickly identify and resolve production issues.
error-debugging-error-analysis
You are an expert error analysis specialist with deep expertise in debugging distributed systems, analyzing production incidents, and implementing comprehensive observability solutions.