- Overview
- Features
- Technology Stack
- System Architecture
- Workflow
- Database Schema
- Installation
- Usage Guide
- Development
- Team
- License
ContainerOps is a comprehensive Continuous Deployment (CD) platform that simplifies Docker-based application deployment through automated Dockerfile generation, GitHub integration, and real-time monitoring capabilities. The platform is designed to empower developers by providing a seamless user experience for deploying applications using Docker orchestration, enabling teams to focus on development while ensuring smooth and secure deployment across various environments.
-
Automated Dockerfile Generation
- Intelligent project structure analysis to detect project type
- Creates optimized Dockerfiles tailored to language and framework requirements
- Supports custom Dockerfile overrides when needed
-
GitHub Integration
- Seamless OAuth authentication for secure repository access
- Supports both public and private repositories
- Webhook integration for automatic deployment on code changes
- Branch selection for deployment flexibility
-
Continuous Deployment Pipeline
- Automatic builds triggered by GitHub commits
- Consistent deployment process across environments
- Rollback capabilities for failed deployments
- Support for environment variables and secrets management
-
Container Management
- Full lifecycle control of Docker containers (create, start, stop, remove)
- Container orchestration with health monitoring
- Resource usage tracking and optimization
- Container versioning and history
-
Live Monitoring
- Real-time build and application logs via WebSockets
- Container status and health checks
- Performance metrics and resource utilization
-
Domain Routing
- Dynamic Nginx configuration for custom domain mappin
- Traffic routing
-
Docker Registry
- Built-in private registry for container images
- Secure storage and distribution of application images
- Version tagging and management
- Framework: Django 3.2 (Python)
- WebSockets: Django Channels
- HTML/CSS: Responsive design with TailWind CSS
- JavaScript: Interactive dashboard components
- Real-time Updates: WebSocket integration
- Containerization: Docker, Docker Compose
- Authentication: Github OAuth 2.0
- Database: PostgreSQL 12+
- Web Server: Nginx for reverse proxy and domain mapping
- CI/CD: Webhook-based automated pipeline
ContainerOps follows a microservices architecture with the following key components:
-
Build Server
- Analyzes project structure and generates optimized Dockerfiles
- Builds Docker images from source code
- Pushes built images to the integrated Docker registry
- Handles GitHub webhooks for automated builds
-
Proxy Server
- Manages container lifecycle (create, start, stop, remove)
- Configures Nginx for domain routing and SSL termination
- Handles user authentication and authorization
- Provides API endpoints for the dashboard
-
Docker Registry
- Stores and distributes Docker images
- Manages image versioning and tagging
- Provides secure access to container images
-
Monitoring Service
- Collects container metrics and logs
- Provides real-time updates via WebSockets
- Monitors container health and performance
-
Database
- Stores user data, repository information, and deployment configurations
- Tracks container status and history
- Maintains system settings and environment variables
-
Authentication & Repository Selection
- User authenticates through GitHub OAuth
- System requests appropriate permissions for repository access
- User selects target repositories for deployment
- System validates repository access and structure
-
Configuration & Setup
- User provides deployment parameters (environment variables, resource limits)
- System analyzes project structure to determine project type
- User selects branch and deployment options
- System validates configuration for potential issues
-
Dockerfile Management
- System auto-generates optimized Dockerfiles based on project type
- User can review and customize generated Dockerfiles
- System uses existing Dockerfile if present in repository
-
Build & Registry
- System clones repository and builds Docker image
- Build logs streamed in real-time via WebSockets
- Built images are tagged and pushed to integrated Docker registry
- Image metadata and version history maintained
-
Deployment Pipeline
- GitHub webhooks trigger automatic deployment on code changes
- System pulls updated images from registry
- Container orchestration manages deployment updates
-
Monitoring & Management
- Interactive dashboard for container status monitoring
- Live build and application log streaming
- Complete container lifecycle management (scale, restart, stop)
- Custom domain and routing configuration
The ContainerOps database schema includes the following core tables:
-
Users
- User authentication and profile information
- OAuth tokens and permissions
- User preferences and settings
-
Repositories
- GitHub repository details and access credentials
- Branch information and webhook configuration
- Project type and structure metadata
-
Deployments
- Container configuration and environment variables
- Resource allocation and limits
- Deployment history and versioning
- Build and runtime logs
-
Containers
- Container status and health metrics
- Resource utilization statistics
- Network configuration and port mappings
- Related deployment and image references
-
Domains
- Custom domain mappings and SSL certificates
- Routing rules and load balancing configuration
- DNS verification status and history
- Python 3.8+
- Docker Engine 20.10+
- Docker Compose 1.29+
- GitHub Developer Account (for OAuth integration)
- PostgreSQL 12+
- Redis 6+
- Nginx 1.18+
git clone https://github.com/yourusername/containerops.git
cd containeropspython -m venv venv
source venv/bin/activate # Linux/Mac
venv\Scripts\activate # Windowscd buildServer
pip install -r requirements.txtcd ../proxy_server
pip install -r requirements.txt# Django Settings
SECRET_KEY=your_django_secret_key
DEBUG=False
ALLOWED_HOSTS=localhost,127.0.0.1,your-domain.com
# Database Configuration
DB_NAME=containerops
DB_USER=postgres
DB_PASSWORD=your_secure_password
DB_HOST=localhost
DB_PORT=5432
# OAuth Credentials
GITHUB_CLIENT_ID=your_github_oauth_id
GITHUB_CLIENT_SECRET=your_github_oauth_secret
GOOGLE_CLIENT_ID=your_google_oauth_id
GOOGLE_CLIENT_SECRET=your_google_oauth_secret
# Docker Registry
DOCKER_REGISTRY_URL=your_registry_url
DOCKER_REGISTRY_USERNAME=registry_username
DOCKER_REGISTRY_PASSWORD=registry_password
# Redis Configuration
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=your_redis_password
# Webhook Secret
WEBHOOK_SECRET=your_webhook_secret_key
# For build server
cd buildServer
python manage.py migrate
# For proxy server
cd ../proxy_server
python manage.py migratepython manage.py createsuperuser# Start proxy server
cd proxy_server
python manage.py runserver 0.0.0.0:8000
# In a new terminal, start build server
cd buildServer
python manage.py runserver 0.0.0.0:8001For production deployment, use Docker Compose:
-
Configure environment variables in
.envfile -
Start the services:
docker-compose up -d
-
Initialize the database (first time only):
docker-compose exec proxy_server python manage.py migrate docker-compose exec build_server python manage.py migrate docker-compose exec proxy_server python manage.py createsuperuser
-
Access the application at
http://your-domain.com
- Navigate to the ContainerOps login page
- Select authentication method (GitHub or Google)
- Grant the requested permissions for repository access
- Complete the profile setup if first-time login
- Browse available repositories from your GitHub account
- Select a repository for deployment
- Choose the branch to deploy (defaults to main/master)
- Configure repository-specific settings and webhooks
- Review the automatically detected project type
- Configure environment variables and secrets
- Set resource limits (CPU, memory)
- Configure custom domain and SSL settings
- Review and customize the generated Dockerfile (optional)
- Initiate the deployment process
- View real-time build logs during deployment
- Monitor container status and health metrics
- Access application logs via the streaming interface
- Configure alerts for container events
- Manage container lifecycle (restart, stop, remove)
containerops/
├── buildServer/ # Build service for Docker images
│ ├── api/ # Build API endpoints
│ ├── dockerfiles/ # Dockerfile templates
│ ├── github/ # GitHub integration
│ ├── builder/ # Image building logic
│ └── management/ # Django management commands
├── proxy_server/ # Proxy service for container management
│ ├── api/ # Proxy API endpoints
│ ├── auth/ # Authentication services
│ ├── containers/ # Container management
│ ├── domains/ # Domain routing
│ └── monitoring/ # Monitoring services
├── frontend/ # Frontend assets and templates
│ ├── static/ # Static files (CSS, JS)
│ └── templates/ # HTML templates
├── common/ # Shared utilities
│ ├── models/ # Shared database models
│ └── utils/ # Helper functions
├── docs/ # Documentation
├── tests/ # Test suite
└── docker-compose.yml # Docker Compose configuration
- Multi-Provider Support: Extend beyond GitHub to support GitLab, Bitbucket, and Azure DevOps
- Advanced Scaling: Horizontal and vertical scaling capabilities for containerized applications
- Enhanced Monitoring: Advanced metrics collection with Prometheus integration
- Multi-Cluster Support: Distributed deployments across multiple Docker hosts or Kubernetes clusters
- CI Pipeline Integration: Complete CI/CD solution with testing frameworks
- Blue-Green Deployments: Advanced deployment strategies for zero-downtime updates
- Service Mesh: Integration with service mesh solutions for microservices
- Custom Plugins: Extensible plugin system for additional functionality
- Team Collaboration: Advanced team management and permission controls
- Cost Optimization: Resource allocation and cost tracking features
- Apoorva Agrawal
- J Hariharan
- Nandan Ramesh
- Krishna Tulsyan
- Adurti V L Varshini
- Sahil Kumar
- Yash Kumar Singh
This project is licensed under the MIT License - see the LICENSE file for details.
ContainerOps © 2025. All rights reserved.