django-coolify 0.1.1

Django integration for Coolify - easy deployment and management

Django Coolify

Easy Django deployment to Coolify with minimal configuration.

Features

• Simple Django integration with Coolify
• Automatic Docker configuration generation
• Git-based deployments for public repositories
• SQLite support with persistent volumes
• Health check integration
• Environment variable management

Installation

pip install django-coolify

Quick Start

1. Add to Django settings:

   # settings.py
   INSTALLED_APPS = [
       # ... your apps
       'django_coolify',
   ]
   

2. Generate configuration:

   python manage.py generate-config --interactive
   

3. Setup infrastructure:

   python manage.py setup-infra
   

4. Deploy your application:

   python manage.py deploy
   

Commands

generate-config

Generate a coolify.json configuration file for your project.

# Interactive mode (recommended for first setup)
python manage.py generate-config --interactive

# Command line mode
python manage.py generate-config \
    --coolify-url https://coolify.example.com \
    --api-token your-api-token \
    --project-name my-django-project \
    --app-name my-django-app \
    --git-repository https://github.com/username/repo \
    --git-branch main \
    --build-pack dockerfile

Options:

• --coolify-url: Your Coolify instance URL
• --api-token: Coolify API token (get from Keys & Tokens in Coolify dashboard)
• --project-name: Project name in Coolify
• --app-name: Application name in Coolify
• --git-repository: Git repository URL (auto-detected if not provided)
• --git-branch: Git branch to deploy (default: main)
• --build-pack: Build pack to use (dockerfile or nixpacks, default: dockerfile)
• --domains: Comma-separated list of domains
• --force: Overwrite existing configuration
• --interactive: Interactive configuration mode

setup-infra

Create project and application in Coolify based on your configuration.

# Basic setup
python manage.py setup-infra

# List available servers
python manage.py setup-infra --list-servers

# Use specific server
python manage.py setup-infra --server-uuid <server-uuid>

# Force recreation of resources
python manage.py setup-infra --force

Options:

• --server-uuid: Specific server UUID to deploy to
• --force: Force recreation of existing resources
• --list-servers: List available servers and exit

deploy

Deploy your application to Coolify.

# Standard deployment
python manage.py deploy

# Force rebuild (no cache)
python manage.py deploy --force

# Deploy specific branch
python manage.py deploy --branch feature-branch

# Deploy specific tag
python manage.py deploy --tag v1.0.0

# Skip git push (code already pushed)
python manage.py deploy --no-push

Options:

• --force: Force rebuild without cache
• --no-push: Skip git push (assume code is already pushed)
• --branch: Deploy specific branch (overrides config)
• --tag: Deploy specific tag instead of branch

Configuration

The coolify.json file contains all the configuration for your deployment:

{
  "coolify_url": "https://coolify.example.com",
  "api_token": "your-api-token",
  "project_name": "my-django-project",
  "project_uuid": "generated-after-setup",
  "app_name": "my-django-app",
  "app_uuid": "generated-after-setup",
  "server_uuid": "auto-selected-or-specified",
  "git_repository": "https://github.com/username/repo",
  "git_branch": "main",
  "build_pack": "dockerfile",
  "domains": "example.com,www.example.com",
  "environment_variables": {},
  "health_check_enabled": true,
  "health_check_path": "/health/"
}

Django Settings for Production

For successful deployment, ensure your Django settings are production-ready:

Required Settings

# settings.py

# Static files - Required for collectstatic
STATIC_URL = 'static/'
STATIC_ROOT = BASE_DIR / 'staticfiles'  # or os.path.join(BASE_DIR, 'staticfiles')

# Allow hosts - Configure for your domain
ALLOWED_HOSTS = ['*']  # For testing, or ['yourdomain.com', 'www.yourdomain.com']

# Optional: Health check endpoint (automatically added by django-coolify)
# No additional configuration needed

Recommended Settings

# For better security in production
import os

# Use environment variables for sensitive data
SECRET_KEY = os.environ.get('SECRET_KEY', 'your-fallback-secret-key')
DEBUG = os.environ.get('DEBUG', 'False').lower() == 'true'

# Database (SQLite with volume mount)
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'data' / 'db.sqlite3',  # Matches Docker volume
    }
}

# Logging (optional)
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
        },
    },
    'root': {
        'handlers': ['console'],
        'level': 'INFO',
    },
}

Docker Configuration

The package automatically generates Docker-related files if they don't exist:

• Dockerfile: Optimized for Django applications
• requirements.txt: Extracted from pyproject.toml or created with sensible defaults
• .dockerignore: Excludes unnecessary files from Docker context

Health Checks

A health check endpoint is automatically added to your Django application at /health/. This endpoint returns a simple JSON response indicating the application status.

Environment Variables

You can configure environment variables in the coolify.json file:

{
  "environment_variables": {
    "DEBUG": "False",
    "ALLOWED_HOSTS": "example.com,www.example.com",
    "SECRET_KEY": "your-secret-key"
  }
}

Getting Your Coolify API Token

1. Log in to your Coolify dashboard
2. Go to "Keys & Tokens" → "API tokens"
3. Click "Create New Token"
4. Give it a name and select appropriate permissions
5. Copy the token (you'll only see it once)

Workflow

The typical workflow for using django-coolify:

1. Initial Setup: Run generate-config --interactive to create your configuration
2. Infrastructure: Run setup-infra to create the project and application in Coolify
3. Development: Make changes to your Django application
4. Deployment: Run deploy to push changes and deploy

Requirements

• Python 3.12+
• Django 4.2+
• Git repository (public repositories supported)
• Coolify instance with API access

Limitations

• Currently supports only public Git repositories
• Requires manual Coolify API token setup
• SQLite database with volume mounting (PostgreSQL support planned)

Contributing

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

License

MIT License