Coolify Deployment

Overview

Coolify is an open-source, self-hostable Platform as a Service (PaaS) that simplifies application deployment. It provides a user-friendly interface for managing Docker-based applications like PhotoFlow.

Coolify is ideal if you want Docker’s benefits without manually managing containers and configurations.

What is Coolify?

Coolify offers:

Web Interface

Manage deployments through a clean UI instead of command line

Automatic Deployments

Deploy from Git repos with automatic rebuilds on push

Built-in Monitoring

View logs, resource usage, and health status

Zero Downtime

Rolling updates without service interruption

Backup Management

Scheduled database backups with easy restoration

SSL Certificates

Automatic HTTPS with Let’s Encrypt

Prerequisites

Before deploying with Coolify:

Server with Linux (Ubuntu 22.04+ recommended)
2 GB RAM minimum (4 GB recommended)
20 GB disk space minimum
Docker installed (Coolify can install it for you)
Domain name (optional, for SSL/HTTPS)
SSH access to your server

Install Coolify

Connect to Server

SSH into your server:

ssh user@your-server-ip

Run Installation Script

Install Coolify with one command:

curl -fsSL https://cdn.coolify.io/install.sh | bash

This installs:

Docker (if not present)
Docker Compose
Coolify application
Required dependencies

Access Coolify

Once installed, access Coolify at:

http://your-server-ip:8000

Complete Setup

Follow the setup wizard:

Create admin account
Set up your first server
Configure basic settings

Coolify installation takes 5-10 minutes depending on your server speed.

PhotoFlow Coolify Configuration

PhotoFlow includes a Coolify-specific Docker Compose file: docker-compose.coolify.yml

docker-compose.coolify.yml

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: ${POSTGRES_USER:-photoflow}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB:-photoflow}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5

  app:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      - DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
      - NODE_ENV=production
      - VITE_SOCKET_URL=${COOLIFY_URL}
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped

volumes:
  postgres_data:

Key differences from standard docker-compose.yml:

Environment variables: Uses ${POSTGRES_PASSWORD} instead of hardcoded values
No port mappings: Coolify handles port exposure
COOLIFY_URL: Automatically set to your deployment URL
Defaults: Uses :- syntax for fallback values

Deploy PhotoFlow to Coolify

Create New Resource

In Coolify dashboard:

Click ”+ New Resource”
Select “Docker Compose”
Choose “From Repository” or “Upload File”

Configure Repository

If deploying from Git:

Repository: https://github.com/DomenicWalther/PhotoFlow.git
Branch: main
Docker Compose file: docker-compose.coolify.yml

Set Environment Variables

In Coolify’s environment configuration, add:

POSTGRES_USER=photoflow
POSTGRES_PASSWORD=your_secure_password_here
POSTGRES_DB=photoflow

Use a strong, unique password for POSTGRES_PASSWORD!

Coolify automatically provides:

COOLIFY_URL - Your app’s public URL

Configure Domain (Optional)

For custom domain:

Add domain in Coolify settings
Point DNS A record to your server IP
Enable “Generate SSL Certificate”

Coolify automatically sets up HTTPS with Let’s Encrypt.

Deploy

Click “Deploy” button.Coolify will:

Clone the repository
Build Docker images
Start containers
Run database migrations
Configure networking

Monitor Deployment

Watch the deployment logs in real-time.Successful deployment shows:

✓ Database healthy
✓ Migrations complete
✓ Application started

Access PhotoFlow

Once deployed, access your PhotoFlow instance at the provided URL:

https://photoflow.yourdomain.com

Managing PhotoFlow in Coolify

View Logs

Access logs through Coolify UI:

Go to your PhotoFlow application
Click “Logs” tab
Select service (app or postgres)
View real-time logs

Restart Services

Navigate to your application
Click “Actions” dropdown
Select “Restart”

Update PhotoFlow

For automatic updates:

Enable “Auto Deploy” in settings
Coolify monitors Git repository
Automatically rebuilds on new commits

For manual updates:

Click “Redeploy” button
Coolify pulls latest code
Rebuilds and restarts containers

Database Backups

Coolify can automate backups:

Go to “Backups” section
Enable automatic backups
Set schedule (daily, weekly, etc.)
Choose backup retention period

Manual backup:

Click “Backup Now”
Download backup file

Environment Variables

Update environment variables:

Go to “Environment” tab
Edit variables
Click “Save”
Redeploy for changes to take effect

Network Configuration

Custom Domain

Set up a custom domain:

Add Domain in Coolify

Application settings → Domains
Add your domain (e.g., photoflow.yourdomain.com)

Configure DNS

Point your domain to the server:

Type: A
Name: photoflow
Value: [your-server-ip]
TTL: 3600

Enable SSL

Coolify automatically:

Requests Let’s Encrypt certificate
Configures HTTPS
Redirects HTTP to HTTPS

Internal Network Access

For local network deployment without internet:

Don’t configure a public domain
Access via server IP:
```
http://192.168.1.100:8000
```
Update VITE_SOCKET_URL manually in environment variables

Monitoring and Health Checks

Resource Usage

Coolify dashboard shows:

CPU usage
Memory usage
Disk space
Network traffic

Health Checks

Coolify monitors:

Container status
PostgreSQL health
Application responsiveness

Receive notifications for:

Deployment failures
Service downtime
Resource limits exceeded

Configure Alerts

Go to Settings → Notifications
Add email or webhook
Choose alert types
Test notifications

Troubleshooting

Deployment failed

Check logs for errors:

View build logs
Look for:
- Missing environment variables
- Build errors
- Port conflicts
Fix issues and redeploy

Database connection errors

Verify:

Environment variables are set correctly
PostgreSQL container is healthy
DATABASE_URL format is correct
No typos in password

SSL certificate issues

If HTTPS isn’t working:

Verify DNS is pointing to correct IP
Wait for DNS propagation (up to 24 hours)
Check port 80 and 443 are open
Try regenerating certificate

Can't access from network

For internal network access:

Use server IP, not localhost
Update VITE_SOCKET_URL to server IP
Ensure firewall allows connections
Redeploy after environment changes

Coolify vs Manual Docker

Feature	Coolify	Manual Docker
Ease of use	✓ Web UI	Command line
Auto updates	✓ Built-in	Manual
SSL/HTTPS	✓ Automatic	Manual setup
Backups	✓ Scheduled	Manual scripts
Monitoring	✓ Dashboard	External tools
Learning curve	Low	Moderate
Flexibility	Limited to UI	Full control
Resource overhead	Higher	Lower

Use Coolify if you want simplicity. Use manual Docker if you need maximum control or are deploying to offline networks.

Cost Considerations

Coolify itself is free and open-source. Costs:

Server hosting - $5-20/month (VPS providers)
Domain name - $10-15/year (optional)
SSL certificate - Free (Let’s Encrypt)

Recommended providers:

DigitalOcean
Linode/Akamai
Hetzner
Vultr

For offline/internal networks, use your own hardware (zero hosting cost).

Best Practices

Secure Passwords

Use strong, unique passwords for:

Coolify admin
PostgreSQL database
Server SSH access

Regular Backups

Enable automated backups:

Daily database backups
Store off-server
Test restoration

Monitor Resources

Check regularly:

Disk space usage
Memory consumption
CPU load

Update Strategy

Keep software current:

Enable auto-deploy
Test in staging first
Review changelogs

Advanced Configuration

Custom Build Arguments

Add build arguments in Coolify:

NODE_VERSION=20
BUILD_ARGS="--no-cache"

Multiple Environments

Deploy staging and production:

Create two applications in Coolify
Use different branches:
- Production: main
- Staging: develop
Use different environment variables

Scaling

Coolify supports scaling:

Go to application settings
Adjust replica count
Coolify manages load balancing

For PhotoFlow, ensure Socket.io is configured for multiple instances (requires sticky sessions or Redis adapter).

Migration from Manual Docker

Moving existing deployment to Coolify:

Backup Data

Export your database:

docker compose exec postgres pg_dump -U photoflow photoflow > backup.sql

Deploy to Coolify

Follow the deployment steps above.

Restore Data

Import your backup:

Access Coolify terminal
Restore database:

cat backup.sql | psql -U photoflow photoflow

Verify

Check all data is present and working.

Update DNS

Point your domain to new server if applicable.

Next Steps

Production Checklist

Ensure your deployment is production-ready

Network Setup

Configure multi-PC network access

Environment Variables

Learn about all configuration options

Docker Deployment

Alternative: Manual Docker deployment

Get Started

Installation

Core Features

Configuration

Deployment

​Overview

​What is Coolify?

Web Interface

Automatic Deployments

Built-in Monitoring

Zero Downtime

Backup Management

SSL Certificates

​Prerequisites

​Install Coolify

​PhotoFlow Coolify Configuration

​Deploy PhotoFlow to Coolify

​Managing PhotoFlow in Coolify

​View Logs

​Restart Services

​Update PhotoFlow

​Database Backups

​Environment Variables

​Network Configuration

​Custom Domain

​Internal Network Access

​Monitoring and Health Checks

​Resource Usage

​Health Checks

​Configure Alerts

​Troubleshooting

​Coolify vs Manual Docker

​Cost Considerations

​Best Practices

Secure Passwords

Regular Backups

Monitor Resources

Update Strategy

​Advanced Configuration

​Custom Build Arguments

​Multiple Environments

​Scaling

​Migration from Manual Docker

​Next Steps

Production Checklist

Network Setup

Environment Variables

Docker Deployment

​Resources

Build docs developers (and LLMs) love

Overview

What is Coolify?

Prerequisites

Install Coolify

PhotoFlow Coolify Configuration

Deploy PhotoFlow to Coolify

Managing PhotoFlow in Coolify

View Logs

Restart Services

Update PhotoFlow

Database Backups

Environment Variables

Network Configuration

Custom Domain

Internal Network Access

Monitoring and Health Checks

Resource Usage

Health Checks

Configure Alerts

Troubleshooting

Coolify vs Manual Docker

Cost Considerations

Best Practices

Advanced Configuration

Custom Build Arguments

Multiple Environments

Scaling

Migration from Manual Docker

Next Steps

Resources