Deployment & Git Workflows

Comprehensive guides for deploying Kailash applications with Docker and Kubernetes, plus Git workflow best practices.

Overview

Production deployment patterns for:

• Docker containerization
• Kubernetes orchestration
• Git workflows and branching strategies
• CI/CD integration
• Environment management

Reference Documentation

Docker Deployment

• deployment-docker-quick - Docker deployment quick start
  • Dockerfile setup for Kailash apps
  • Docker Compose configurations
  • Multi-stage builds
  • Environment variables
  • Volume management
  • Health checks
  • Production optimizations

Kubernetes Deployment

• deployment-kubernetes-quick - Kubernetes deployment guide
  • Deployment manifests
  • Service configuration
  • ConfigMaps and Secrets
  • Persistent volumes
  • Health probes
  • Scaling strategies
  • Ingress setup

Git Workflow

• git-workflow-quick - Git workflow best practices
  • Branching strategies
  • Commit conventions
  • Pull request workflow
  • Code review process
  • Release management
  • Hotfix procedures

Docker Patterns

Basic Dockerfile

FROM python:3.11-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application
COPY . .

# Use AsyncLocalRuntime for Docker
ENV RUNTIME_TYPE=async

# Health check
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8000/health || exit 1

# Run with Nexus
CMD ["python", "-m", "app.main"]

Docker Compose

version: '3.8'
services:
  nexus:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
      - RUNTIME_TYPE=async
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      - POSTGRES_PASSWORD=pass
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Kubernetes Patterns

Deployment Manifest

apiVersion: apps/v1
kind: Deployment
metadata:
  name: kailash-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: kailash
  template:
    metadata:
      labels:
        app: kailash
    spec:
      containers:
      - name: app
        image: my-kailash-app:latest
        ports:
        - containerPort: 8000
        env:
        - name: RUNTIME_TYPE
          value: "async"
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 10
          periodSeconds: 30

Git Workflow Patterns

Branch Strategy

main (production)
  ↓
develop (integration)
  ↓
feature/* (new features)
hotfix/* (urgent fixes)
release/* (release prep)

Commit Conventions

feat: Add user authentication workflow
fix: Resolve async runtime threading issue
docs: Update DataFlow integration guide
test: Add cycle workflow test cases
chore: Bump version to 0.9.25

Critical Rules

Docker

• ✅ Use AsyncLocalRuntime for Docker/FastAPI
• ✅ Implement health checks
• ✅ Use multi-stage builds for smaller images
• ✅ Set proper resource limits
• ✅ Use secrets for sensitive data
• ❌ NEVER use LocalRuntime in Docker (causes hangs)
• ❌ NEVER commit secrets to images
• ❌ NEVER run as root user

Kubernetes

• ✅ Define resource requests and limits
• ✅ Use ConfigMaps for configuration
• ✅ Implement readiness and liveness probes
• ✅ Use Horizontal Pod Autoscaling
• ✅ Set up proper monitoring
• ❌ NEVER store secrets in plain text
• ❌ NEVER skip health checks
• ❌ NEVER use latest tag in production

Git

• ✅ Use feature branches for development
• ✅ Write descriptive commit messages
• ✅ Squash commits before merging
• ✅ Use pull requests for code review
• ✅ Tag releases semantically
• ❌ NEVER commit directly to main
• ❌ NEVER force push to shared branches
• ❌ NEVER commit sensitive data

Runtime Selection

Environment	Runtime	Reason
Docker	AsyncLocalRuntime	No threading, async-first
K8s	AsyncLocalRuntime	Container-optimized
FastAPI	AsyncLocalRuntime	Native async support
CLI	LocalRuntime	Synchronous execution
Scripts	LocalRuntime	Simple sync context

When to Use This Skill

Use this skill when you need to:

• Deploy Kailash apps with Docker
• Set up Kubernetes deployments
• Configure CI/CD pipelines
• Establish Git workflows
• Containerize workflows
• Scale applications in production
• Manage environments and secrets

Environment Management

Development

# Local development
python -m app.main

# Docker development
docker-compose up

Production

# Docker production
docker build -t app:prod .
docker run -d -p 8000:8000 app:prod

# Kubernetes production
kubectl apply -f k8s/
kubectl scale deployment kailash-app --replicas=5

Related Skills

• 03-nexus - Application deployment
• 02-dataflow - Database in containers
• 01-core-sdk - Runtime selection
• 17-gold-standards - Deployment best practices

Support

For deployment help, invoke:

• deployment-specialist

  - Docker and Kubernetes expertise

• git-release-specialist

  - Git workflows and releases

• nexus-specialist

  - Application configuration