Modern Docker and Kubernetes Management System

Docky is a powerful, modern CLI tool for managing Docker containers, Docker Compose applications, and Kubernetes deployments. Built with Python 3.11+, featuring a beautiful terminal interface powered by Rich and Typer.

• Cluster Orchestration: Create and manage clusters of Docker containers
• Real-time Monitoring: Live resource statistics (CPU, memory, network, disk I/O)
• Log Aggregation: Consolidated logging from multiple containers
• Dynamic Scaling: Scale clusters up or down on demand

• Multi-service Management: Deploy complex applications with a single command
• Service Scaling: Scale individual services independently
• Log Streaming: Real-time logs from compose services
• Health Checks: Built-in service health monitoring

• Deployment Management: Create, scale, and delete K8s deployments
• Multi-namespace Support: Manage resources across namespaces
• Log Access: Stream logs from pods and deployments
• Status Monitoring: Track deployment health and replica status

• Beautiful Terminal UI: Rich tables, progress bars, and color-coded output
• Intuitive Commands: Simple, memorable command structure
• Tab Completion: Bash/Zsh/Fish shell completion
• Live Updates: Real-time feedback with spinners and progress indicators

# Clone the repository
git clone https://github.com/tmessinis/docky.git
cd docky

# Install with Poetry (recommended)
pip install poetry
poetry install
poetry shell

# Or with pip
pip install -e .

pip install docky

• Python 3.11+
• Docker installed and running
• Docker Compose (for compose commands)
• kubectl configured (for Kubernetes commands)

# Check system health
docky health

# Get help
docky --help

# Version info
docky version

# Create a simple cluster
docky cluster create my-web-cluster --image nginx:alpine --replicas 5

# Create with custom settings
docky cluster create api-cluster \
  --image myapp:latest \
  --replicas 10

docky cluster list

# Scale up
docky cluster scale my-web-cluster --replicas 20

# Scale down
docky cluster scale my-web-cluster --replicas 2

# Get recent logs
docky cluster logs my-web-cluster --tail 100

# Follow logs in real-time
docky cluster logs my-web-cluster --follow

# Stop and remove containers
docky cluster stop my-web-cluster

# Stop but keep containers
docky cluster stop my-web-cluster --no-remove

# Start all services
docky compose up

# Start with custom file
docky compose up --file path/to/docker-compose.yml

# Build images before starting
docky compose up --build

# Custom project name
docky compose up --project my-project

docky compose ps

# All services
docky compose logs

# Specific service
docky compose logs --service api

# Follow logs
docky compose logs --follow

# Stop and remove
docky compose down

# Remove volumes too
docky compose down --volumes

# Simple deployment
docky k8s deploy my-app \
  --image nginx:alpine \
  --replicas 3 \
  --port 80

# With custom namespace
docky k8s deploy my-app \
  --image myapp:latest \
  --replicas 5 \
  --namespace production \
  --port 8080

# Default namespace
docky k8s list

# Specific namespace
docky k8s list --namespace production

docky k8s scale my-app --replicas 10 --namespace production

# Get logs
docky k8s logs my-app

# Follow logs
docky k8s logs my-app --follow --namespace production

docky k8s delete my-app --namespace production

# View cluster stats
docky monitor stats my-web-cluster

# Continuous monitoring
watch -n 2 docky monitor stats my-web-cluster

Output includes:

• CPU usage per container
• Memory usage and limits
• Network I/O (RX/TX)
• Block I/O (Read/Write)
• Process count

Check out the examples/ directory for exciting use cases:

• Simple Docker Cluster: Quick start with nginx
• Docker Compose Stack: Multi-service application
• Kubernetes Deployment: K8s basics

• Microservices Architecture: Complete microservices stack with API gateway, databases, caching, and message queues
• Monitoring Stack: Full observability with Prometheus, Grafana, Loki, and Jaeger
• Multi-Cloud Deployment: Deploy across different cloud providers

See examples/README.md for detailed tutorials.

Docky provides a modern, colorful terminal experience:

╭──────────────── Docker Clusters ────────────────╮
│ Cluster Name      Status      Containers       │
├──────────────────────────────────────────────────┤
│ my-web-cluster   RUNNING            5          │
│ api-cluster      RUNNING           10          │
│ test-cluster     STOPPED            0          │
╰──────────────────────────────────────────────────╯

Create a .env file in your project root:

# Docker Settings
DOCKY_DOCKER_SOCKET=unix:///var/run/docker.sock

# Kubernetes Settings
DOCKY_KUBERNETES_NAMESPACE=default
# DOCKY_KUBECONFIG_PATH=~/.kube/config

# Data Storage
# DOCKY_DATA_DIR=~/.docky

See .env.example for all options.

┌─────────────────────────────────────────┐
│          CLI (Typer + Rich)             │
├─────────────────────────────────────────┤
│                                         │
│  ┌──────────┐  ┌──────────┐  ┌──────┐ │
│  │  Docker  │  │ Compose  │  │  K8s │ │
│  │ Provider │  │ Provider │  │ Prov │ │
│  └──────────┘  └──────────┘  └──────┘ │
│                                         │
├─────────────────────────────────────────┤
│         Configuration Manager           │
└─────────────────────────────────────────┘

• CLI Framework: Typer (modern CLI framework)
• Terminal UI: Rich (beautiful terminal formatting)
• Docker SDK: Official Python Docker SDK
• Kubernetes: Official Python Kubernetes client
• Configuration: Pydantic (data validation)
• Storage: JSON-based persistence

# Clone repository
git clone https://github.com/tmessinis/docky.git
cd docky

# Install dependencies
poetry install

# Activate virtual environment
poetry shell

# Run tests
pytest

# Format code
black src/
ruff check src/

docky/
├── src/docky/
│   ├── cli.py              # CLI entry point
│   ├── models.py           # Pydantic models
│   ├── config.py           # Configuration management
│   ├── providers/          # Provider implementations
│   │   ├── docker_provider.py
│   │   ├── compose_provider.py
│   │   └── kubernetes_provider.py
│   ├── core/               # Core functionality
│   └── utils/              # Utility functions
├── examples/               # Example configurations
├── tests/                  # Test suite
├── pyproject.toml          # Project dependencies
└── README.md

• Modern Python 3.11+ codebase
• Docker cluster management
• Docker Compose support
• Kubernetes integration
• Real-time monitoring
• Beautiful CLI with Rich
• Configuration management

• Interactive TUI with Textual
• REST API with FastAPI
• WebSocket for live updates
• Multi-cloud support (AWS ECS, Azure ACI)
• Advanced health checks
• Automated rollbacks

• Web dashboard (React)
• GitOps integration
• Cost optimization features
• AI-powered recommendations
• Plugin system
• Service mesh support

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

This project is licensed under the MIT License - see the LICENSE file for details.

• Original delivery-tool by @tmessinis
• Built with Typer
• Terminal UI powered by Rich
• Docker SDK by Docker Inc.
• Kubernetes Python Client

• GitHub: @tmessinis
• Issues: GitHub Issues

Transform your container management with Docky! 🚀