---

name: deployment-git description: "Deployment and Git workflow guides for Kailash applications including Docker deployment, Kubernetes orchestration, and Git workflows. Use when asking about 'deployment', 'Docker deployment', 'Kubernetes deployment', 'containerization', 'K8s', 'Git workflow', 'Git branching', 'CI/CD', 'production deployment', 'Docker compose', or 'container orchestration'."

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

CopyFROM 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

Copyversion: '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

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

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

Commit Conventions

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

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

Copy# Local development
python -m app.main

# Docker development
docker-compose up

Production

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