cloud-native-todo-deployer

# Cloud-Native Todo Deployer Skill

A comprehensive skill for containerizing full-stack Todo applications and deploying them to Kubernetes using AI-assisted DevOps tools. This skill automates the entire process from containerization to deployment with no manual coding required.

## When to Use This Skill

Use this skill when you need to:
- Containerize a full-stack Todo application (frontend + backend)
- Create production-ready Docker images
- Generate Helm charts for Kubernetes deployment
- Deploy to local Kubernetes (Minikube) or cloud clusters
- Use AI-assisted DevOps tools (Gordon, kubectl-ai, Kagent)
- Implement spec-driven deployment processes

## Prerequisites

Before using this skill, ensure you have:
- Docker installed with Kubernetes enabled OR Minikube
- Helm 3.x installed
- kubectl installed
- Access to the frontend and backend source code
- (Optional) Access to AI tools: Gordon, kubectl-ai, Kagent

## Inputs

- `frontend_path`: Local path to the frontend Todo app source code
- `backend_path`: Local path to the backend Todo app source code
- `docker_registry`: Docker registry to push images (optional, can be local) [default: "local"]
- `helm_output_path`: Path to save generated Helm charts [default: "./helm-charts"]
- `namespace`: Kubernetes namespace for deployment [default: "todo-app"]
- `replicas_frontend`: Number of replicas for the frontend deployment [default: 2]
- `replicas_backend`: Number of replicas for the backend deployment [default: 2]
- `minikube_profile`: Minikube profile name for local deployment [default: "todo-minikube"]

## Execution Workflow

### 1. Containerization Phase
The skill will:
- Generate optimized Dockerfiles for both frontend and backend applications
- Build production-ready container images
- Apply multi-stage builds for security and optimization
- Include health checks and proper resource allocation

For the frontend (Next.js/React), it will create a Dockerfile with:
- Node.js base image (node:20-alpine)
- Multi-stage build with build artifacts separation
- Production build optimization
- Health check endpoint

For the backend (Python/FastAPI), it will create a Dockerfile with:
- Python base image (python:3.11-slim)
- Dependency installation in separate layer
- Security best practices (non-root user)
- Health check endpoint

### 2. Helm Chart Generation Phase
The skill will generate complete Helm charts for:
- Frontend service with deployment, service, and ingress
- Backend service with deployment, service, and proper networking
- ConfigMaps for configuration management
- Secrets for sensitive data
- Horizontal Pod Autoscalers for scaling

### 3. Deployment Phase
The skill will:
- Set up Kubernetes cluster (Minikube if needed)
- Create the specified namespace
- Deploy backend service first (dependency ordering)
- Deploy frontend service with proper service discovery
- Configure auto-scaling and health checks
- Validate deployment completion

## AI Tool Integration

The skill leverages AI-assisted DevOps tools when available:

### Gordon (Docker AI)
- Generate optimized Dockerfiles for both services
- Build and optimize container images
- Apply security scanning and best practices

### kubectl-ai
- Deploy applications to Kubernetes
- Scale deployments based on load
- Troubleshoot deployment issues
- Manage configuration updates

### Kagent
- Monitor cluster health
- Analyze resource utilization
- Optimize deployment performance

## Scripts Available

The skill includes pre-built scripts for common operations:

### Containerization Scripts
- `scripts/build-frontend-image.sh` - Build frontend container image
- `scripts/build-backend-image.sh` - Build backend container image
- `scripts/optimize-images.sh` - Optimize images for production

### Deployment Scripts
- `scripts/deploy-full-stack.sh` - Deploy both frontend and backend
- `scripts/validate-deployment.sh` - Validate deployment status
- `scripts/rollback-deployment.sh` - Rollback to previous version

### Helm Management Scripts
- `scripts/generate-helm-charts.sh` - Generate Helm charts from templates
- `scripts/upgrade-deployment.sh` - Upgrade deployment with new charts
- `scripts/uninstall-deployment.sh` - Remove deployment cleanly

## Configuration Management

The skill implements proper configuration management:
- Environment variables via ConfigMaps
- Sensitive data via Kubernetes Secrets
- Externalized configuration for different environments
- Secure handling of API keys and database connections

## Auto-Scaling Configuration

Both frontend and backend deployments include:
- Horizontal Pod Autoscaler (HPA) configurations
- CPU and memory-based scaling triggers
- Minimum and maximum replica bounds
- Proper resource requests and limits

## Health Checks and Monitoring

Built-in health checks for both services:
- Liveness probes to restart unhealthy pods
- Readiness probes to remove unhealthy pods from service
- Application-level health endpoints
- Kubernetes-native monitoring integration

## Output

Upon successful execution, the skill provides:
- `frontend_image`: Tagged frontend Docker image reference
- `backend_image`: Tagged backend Docker image reference
- `helm_frontend_chart`: Path to generated frontend Helm chart
- `helm_backend_chart`: Path to generated backend Helm chart
- `deployment_status`: Current status of the deployment

## Error Handling

The skill includes comprehensive error handling:
- Validation of prerequisites before starting
- Rollback capabilities if deployment fails
- Detailed error messages for troubleshooting
- Automatic retry mechanisms for transient failures

## Best Practices Implemented

- **Security**: Non-root containers, minimal base images, secrets management
- **Scalability**: Horizontal pod autoscaling, proper resource allocation
- **Reliability**: Health checks, readiness probes, graceful shutdown
- **Maintainability**: Clean separation of concerns, documented configurations
- **Observability**: Built-in monitoring, logging, and metrics

## Troubleshooting

If deployment issues occur, check:
- Docker daemon is running and accessible
- Kubernetes cluster is available and connected
- Required ports are not in use
- Sufficient system resources (memory, disk space)
- Network connectivity for pulling images

## Success Criteria

Deployment is successful when:
- All pods are running and healthy
- Services are accessible via Kubernetes services
- Health checks are passing
- Auto-scaling is configured and functional
- Both frontend and backend can communicate
- All application features are working correctly