Containerization with Claude Code

Containerization with Claude Code

Claude Code excels at containerization tasks, from writing Dockerfiles to orchestrating complex Kubernetes deployments. This lesson covers practical patterns for using Claude Code in containerized environments.

Prerequisites

Tip

Ensure you have Docker installed and running on your system. For Kubernetes examples, you’ll need either minikube, kind, or access to a K8s cluster.

Docker Workflows

Creating Optimized Dockerfiles

Claude Code can analyze your application and generate production-ready Dockerfiles:

Node.js

# Generate a multi-stage Dockerfile
claude "Create a multi-stage Dockerfile for this Node.js app with:
- Build stage with dependencies
- Production stage with minimal image
- Non-root user
- Health checks
- Security best practices"

Python

# Python app with poetry
claude "Create a Dockerfile for this Python Flask app:
- Use poetry for dependency management
- Multi-stage build
- Alpine Linux for smaller image
- Gunicorn for production
- Include security scanning"

Go

# Go microservice
claude "Generate a Dockerfile for this Go service:
- Multi-stage build with module caching
- Scratch or distroless final image
- Include ca-certificates
- Proper signal handling
- Build-time variables"

Docker Compose Development

1. Analyze project structure

   claude "Analyze this project and create a docker-compose.yml with:
   - All services properly networked
   - Volume mounts for development
   - Environment variable management
   - Health checks and dependencies"

2. Add development overrides

   claude "Create docker-compose.override.yml for local development with:
   - Hot reloading
   - Exposed debugging ports
   - Local volume mounts
   - Development environment variables"

3. Production configuration

   claude "Create docker-compose.prod.yml with:
   - Production-ready settings
   - Resource limits
   - Restart policies
   - Logging configuration"

Container Security Scanning

# Analyze Dockerfile for security issues
claude "Review this Dockerfile for security vulnerabilities:
- Check for hardcoded secrets
- Verify non-root user
- Analyze base image security
- Suggest improvements
Include commands to scan with trivy/grype"

Kubernetes Orchestration

Generating K8s Manifests

Complete Application Deployment

claude "Create Kubernetes manifests for this application:
- Deployment with proper resource limits
- Service for load balancing
- ConfigMap for configuration
- Secret for sensitive data
- Ingress for external access
- HPA for autoscaling
Follow Kubernetes best practices"

Helm Chart Creation

1. Initialize Helm structure

   claude "Create a Helm chart for this application:
   - Generate Chart.yaml with metadata
   - Create flexible values.yaml
   - Template all Kubernetes resources
   - Include NOTES.txt for usage"

2. Add environment-specific values

   claude "Create values files for different environments:
   - values-dev.yaml with lower resources
   - values-staging.yaml with moderate settings
   - values-prod.yaml with HA configuration
   Include proper overrides"

3. Create helper templates

   claude "Add Helm template helpers for:
   - Common labels and selectors
   - Resource name generation
   - Configuration validation
   - Conditional resource creation"

GitOps Integration

# ArgoCD application manifest
claude "Create ArgoCD application manifest:
- Point to Git repository
- Set sync policies
- Configure health checks
- Add resource hooks
- Include rollback configuration"

Advanced Patterns

Multi-Architecture Builds

claude "Update Dockerfile and CI/CD for multi-arch builds:
- Support amd64 and arm64
- Use buildx for cross-compilation
- Push to registry with manifest list
- Include GitHub Actions workflow"

Service Mesh Integration

Istio

claude "Add Istio configuration for this service:
- VirtualService for routing
- DestinationRule for load balancing
- PeerAuthentication for mTLS
- AuthorizationPolicy for access control"

Linkerd

claude "Configure Linkerd for this application:
- Service profiles
- Traffic policies
- Retry configuration
- Circuit breaking rules"

Container Optimization

Image Size Reduction

claude "Optimize this Docker image:
- Analyze layers with dive
- Remove unnecessary dependencies
- Use distroless or Alpine
- Implement multi-stage builds
- Minimize layer count"

Build Performance

claude "Improve Docker build speed:
- Optimize layer caching
- Use BuildKit features
- Implement dependency caching
- Parallelize build steps
- Add .dockerignore"

Debugging Containerized Apps

Container Troubleshooting

# Debug running container
claude "Create debugging scripts for:
- Exec into running containers
- Check logs across multiple containers
- Monitor resource usage
- Test inter-container networking
- Verify environment variables"

Kubernetes Debugging

1. Pod investigation

   claude "Create K8s debugging commands for:
   - Describe pod issues
   - Check events and logs
   - Verify resource limits
   - Test network policies
   - Debug init containers"

2. Cluster-wide debugging

   claude "Generate cluster debugging script:
   - Check node resources
   - Verify DNS resolution
   - Test service connectivity
   - Analyze pod scheduling
   - Review RBAC permissions"

CI/CD Integration

GitHub Actions Docker Workflow

claude "Create GitHub Actions workflow for:
- Build and test Docker images
- Security scanning with Trivy
- Push to registry (DockerHub/ECR/GCR)
- Deploy to Kubernetes
- Rollback on failure"

GitLab CI Pipeline

claude "Generate .gitlab-ci.yml for:
- Docker image building
- Container scanning
- Deploy to multiple environments
- Use GitLab container registry
- Implement review apps"

Best Practices Checklist

Caution

Always review generated configurations for security and compliance with your organization’s policies.

Security Hardening

• ✅ Non-root user in containers
• ✅ Minimal base images
• ✅ No hardcoded secrets
• ✅ Security scanning in CI/CD
• ✅ Network policies enabled
• ✅ Resource limits defined

Performance Optimization

• ✅ Multi-stage builds
• ✅ Layer caching optimized
• ✅ Health checks implemented
• ✅ Graceful shutdown handling
• ✅ Horizontal scaling configured

Practical Exercises

1. Containerize a microservice

   • Take an existing application
   • Create optimized Dockerfile
   • Add docker-compose for local dev
   • Implement health checks

2. Deploy to Kubernetes

   • Generate K8s manifests
   • Create Helm chart
   • Set up autoscaling
   • Configure monitoring

3. Implement CI/CD

   • Build multi-arch images
   • Add security scanning
   • Deploy to staging/production
   • Implement rollback strategy

Common Pitfalls

Avoid These Mistakes

• Running containers as root
• Hardcoding configuration in images
• Not setting resource limits
• Ignoring security scanning
• Missing health checks
• Poor layer caching strategy

Next Steps

Now that you understand containerization with Claude Code, explore:

• Architecture Design for system design
• CI/CD Integration for automation
• Deployment Patterns for production workflows

Remember: Claude Code’s strength in containerization comes from its ability to understand your entire application context and generate appropriate configurations. Always validate generated configs in a safe environment before production use.