Containerization Assistant

Containerization Assistant

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

Quick Start

Generate a Dockerfile

For existing templates:

# 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

# 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 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:

# 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:

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

4. Build and Test

# 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 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 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:

# 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

# 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

# Order layers from least to most frequently changing
COPY package*.json ./  # Changes less often
RUN npm ci
COPY . .  # Changes more often

# Use .dockerignore
# node_modules
# .git
# *.md

For comprehensive best practices, see dockerfile_best_practices.md.

Kubernetes Deployment

Basic Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:1.0.0
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

Service + Ingress

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  type: ClusterIP
  selector:
    app: myapp
  ports:
  - port: 80
    targetPort: 8080
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  tls:
  - hosts:
    - myapp.example.com
    secretName: myapp-tls
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: myapp-service
            port:
              number: 80

For complete Kubernetes patterns including ConfigMaps, Secrets, StatefulSets, Jobs, and more, see kubernetes_patterns.md.

Configuration Management

Environment Variables

Development (.env):

NODE_ENV=development
DATABASE_URL=postgresql://localhost/myapp_dev
DEBUG=true

Production (Kubernetes Secret):

apiVersion: v1
kind: Secret
metadata:
  name: myapp-secrets
type: Opaque
stringData:
  database_url: "postgresql://prod-db/myapp"
  api_key: "secret-key"

ConfigMaps

apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp-config
data:
  log_level: "info"
  feature_flags: |
    {
      "new_ui": true,
      "beta_features": false
    }

Troubleshooting

Docker Build Issues

Problem: Build fails with permission errors

Solution:

RUN chown -R appuser:appuser /app
USER appuser

Problem: Image too large

Solution:

• Use multi-stage builds
• Use Alpine base images
• Add .dockerignore file
• Clean up in same RUN layer

Container Runtime Issues

Problem: Container exits immediately

Solution:

• Check CMD/ENTRYPOINT
• Verify application starts correctly
• Check logs: docker logs <container>

Problem: Cannot connect to container

Solution:

• Verify port mapping: -p 3000:3000
• Check application binds to 0.0.0.0, not localhost
• Verify EXPOSE directive in Dockerfile

Kubernetes Issues

Problem: Pod stuck in Pending state

Solution:

kubectl describe pod <pod-name>
# Check events for resource constraints or image pull issues

Problem: Pod crashes with OOMKilled

Solution:

resources:
  limits:
    memory: "512Mi"  # Increase memory limit

Reference Documentation

Dockerfile Best Practices

See dockerfile_best_practices.md for:

• Multi-stage build patterns
• Layer caching optimization
• Security best practices
• Image size optimization
• Health checks
• Language-specific patterns (Node.js, Python, Java, Go)
• Development vs Production configurations

Kubernetes Patterns

See kubernetes_patterns.md for:

• Deployments and StatefulSets
• Services (ClusterIP, LoadBalancer, NodePort)
• ConfigMaps and Secrets
• Ingress with TLS
• HorizontalPodAutoscaler
• PersistentVolumeClaims
• Jobs and CronJobs
• Health probes (liveness, readiness, startup)
• NetworkPolicies
• Multi-container pods and init containers

Advanced Topics

CI/CD Integration

GitHub Actions:

name: Build and Push Docker Image

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Build Docker image
        run: docker build -t myapp:${{ github.sha }} .

      - name: Push to registry
        run: |
          echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
          docker push myapp:${{ github.sha }}

Image Registry

Push to Docker Hub:

docker tag myapp:1.0.0 username/myapp:1.0.0
docker push username/myapp:1.0.0

Push to AWS ECR:

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 123456789.dkr.ecr.us-east-1.amazonaws.com
docker tag myapp:1.0.0 123456789.dkr.ecr.us-east-1.amazonaws.com/myapp:1.0.0
docker push 123456789.dkr.ecr.us-east-1.amazonaws.com/myapp:1.0.0

Helm Charts

For complex Kubernetes deployments, consider using Helm charts for templated manifests and version management.