containerization-assistant

# Containerization Assistant

Generate production-ready Docker and Kubernetes configurations for your applications.

## Quick Start

### Generate a Dockerfile

**For existing templates**:
```bash
# Node.js application
cp assets/Dockerfile.nodejs ./Dockerfile

# Python application
cp assets/Dockerfile.python ./Dockerfile

# Java application (Spring Boot)
cp assets/Dockerfile.java ./Dockerfile

# Go application
cp assets/Dockerfile.go ./Dockerfile
```

**For custom generation**: Describe your application stack and requirements, and a custom Dockerfile will be generated.

### Generate Docker Compose

```bash
# Multi-service application template
cp assets/docker-compose.yml ./
cp assets/.env.example ./.env

# Edit .env with your configuration
```

### Generate Kubernetes Manifests

Kubernetes configurations are generated based on your deployment requirements. See **[kubernetes_patterns.md](references/kubernetes_patterns.md)** for complete examples.

## Available Templates

### Dockerfiles

**Node.js** (`assets/Dockerfile.nodejs`):
- Multi-stage build for minimal image size
- Alpine-based (~170MB vs ~900MB)
- Non-root user for security
- Production-optimized dependencies

**Python** (`assets/Dockerfile.python`):
- Multi-stage build with builder pattern
- Slim base image
- User-space pip installations
- Non-root user

**Java** (`assets/Dockerfile.java`):
- Multi-stage build with JDK builder
- JRE-only runtime for smaller image
- Spring Boot optimized
- Non-root user

**Go** (`assets/Dockerfile.go`):
- Multi-stage build
- Minimal Alpine runtime
- Static binary compilation
- Non-root user

### Docker Compose

**Multi-service stack** (`assets/docker-compose.yml`):
- Web application service
- PostgreSQL database
- Redis cache
- Nginx reverse proxy
- Health checks
- Volume management
- Network isolation

### Environment Configuration

**Environment template** (`assets/.env.example`):
- Database credentials
- Application secrets
- Service configuration
- API keys

## Generation Workflow

### 1. Analyze Project

Identify:
- Programming language and framework
- Dependencies and build tools
- Runtime requirements
- Services needed (database, cache, etc.)

### 2. Choose Approach

**Template-based**:
- Use for common stacks (Node.js, Python, Java, Go)
- Copy and customize template
- Fast and reliable

**Custom generation**:
- Use for unique requirements
- Generate from scratch
- Full customization

### 3. Customize Configuration

**Dockerfile customization**:
```dockerfile
# Update base image version
FROM node:18-alpine  # Change version as needed

# Add build arguments
ARG NODE_ENV=production

# Modify exposed port
EXPOSE 3000  # Change to your port

# Update startup command
CMD ["node", "server.js"]  # Change to your entry point
```

**Docker Compose customization**:
```yaml
services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"  # Change port mapping
    environment:
      - DATABASE_URL=${DATABASE_URL}  # Add environment variables
```

### 4. Build and Test

```bash
# Build Docker image
docker build -t myapp:1.0.0 .

# Test locally
docker run -p 3000:3000 myapp:1.0.0

# Test with Docker Compose
docker-compose up -d

# View logs
docker-compose logs -f

# Stop services
docker-compose down
```

### 5. Optimize and Deploy

See **[dockerfile_best_practices.md](references/dockerfile_best_practices.md)** for:
- Image size optimization
- Security hardening
- Build caching strategies
- Multi-stage build patterns

## Common Scenarios

### Scenario 1: Containerize Node.js Express API

**Requirements**: Node.js 18, PostgreSQL database, Redis cache

**Steps**:
1. Use `Dockerfile.nodejs` template
2. Use `docker-compose.yml` for local development
3. Customize environment variables
4. Add health check endpoint

**Generated files**:
- `Dockerfile` - Multi-stage Node.js build
- `docker-compose.yml` - Web, PostgreSQL, Redis services
- `.env` - Configuration variables
- `.dockerignore` - Exclude unnecessary files

### Scenario 2: Containerize Python Django Application

**Requirements**: Python 3.11, PostgreSQL, Celery workers

**Steps**:
1. Use `Dockerfile.python` template
2. Generate custom docker-compose with Celery service
3. Add migration init container
4. Configure health checks

**Generated files**:
- `Dockerfile` - Multi-stage Python build
- `docker-compose.yml` - Web, PostgreSQL, Redis, Celery
- `celery-worker.Dockerfile` - Celery worker image
- `.env` - Database and Celery configuration

### Scenario 3: Deploy to Kubernetes

**Requirements**: Deploy containerized app to Kubernetes with scaling

**Steps**:
1. Build and push Docker image
2. Generate Deployment manifest
3. Generate Service (LoadBalancer)
4. Generate Ingress with TLS
5. Add HorizontalPodAutoscaler

See **[kubernetes_patterns.md](references/kubernetes_patterns.md)** for complete examples.

### Scenario 4: Microservices Architecture

**Requirements**: Multiple services (API, Auth, Workers) with shared database

**Steps**:
1. Generate Dockerfile for each service
2. Create docker-compose with all services
3. Configure service discovery
4. Set up shared networks and volumes

**Generated structure**:
```
services/
  api/
    Dockerfile
  auth/
    Dockerfile
  worker/
    Dockerfile
docker-compose.yml
.env
```

## Dockerfile Best Practices

### Multi-Stage Builds

Reduce image size by separating build and runtime:

```dockerfile
# Build stage
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
CMD ["node", "dist/index.js"]
```

### Security

```dockerfile
# Use non-root user
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001 -G nodejs
USER nodejs

# Use specific versions
FROM node:18.17.0-alpine  # Not 'latest'

# Scan for vulnerabilities
# docker scan myapp:latest
```

### Optimization

```dockerf