Database & Service Management

Coolify treats databases as first-class resources. Instead of manually running docker run postgres, you click a button, configure a few options, and get a production-ready database with:

• Persistent storage that survives container restarts
• Internal networking for secure app connections
• Backup scheduling with multiple destinations
• Resource limits to prevent runaway queries

PostgreSQL is the go-to choice for most applications. Let's spin one up.

Create the Database

1. Go to Projects → Select your project (or create one called "Databases")
2. Click Add Resource → Database → PostgreSQL
3. Configure the basics (see table below)
4. Click Create

Resource Configuration

Recommended settings for a 4GB RamNode VPS:

Your apps and databases run in Docker containers. Coolify makes connecting them straightforward through internal networking.

Internal Connection URLs

Every database resource shows its connection details:

Internal URL: postgres-main:5432
Database: app_production
Username: app_user
Password: ••••••••••

The internal URL uses the container name as the hostname. This works because Coolify places resources in the same Docker network.

Configure Your App's Environment

DATABASE_URL=postgresql://app_user:your-password@postgres-main:5432/app_production

Or individual variables if your framework prefers:

DB_HOST=postgres-main
DB_PORT=5432
DB_NAME=app_production
DB_USER=app_user
DB_PASSWORD=your-password

Connection String Formats

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'HOST': os.environ.get('DB_HOST'),
        'PORT': os.environ.get('DB_PORT', 5432),
        'NAME': os.environ.get('DB_NAME'),
        'USER': os.environ.get('DB_USER'),
        'PASSWORD': os.environ.get('DB_PASSWORD'),
    }
}

DB_CONNECTION=pgsql
DB_HOST=postgres-main
DB_PORT=5432
DB_DATABASE=app_production
DB_USERNAME=app_user
DB_PASSWORD=your-password

Some applications require MySQL. The process is nearly identical to PostgreSQL.

1. Add Resource → Database → MySQL (or MariaDB)
2. Configure (see table below)
3. Click Create

MySQL Connection Strings

mysql://app_user:password@mysql-main:3306/app_production

define('DB_HOST', 'mysql-main');
define('DB_NAME', 'app_production');
define('DB_USER', 'app_user');
define('DB_PASSWORD', 'your-password');

Redis serves as a cache, session store, message broker, or queue backend. It's essential for scaling applications.

1. Add Resource → Database → Redis
2. Configure: Name (redis-cache), Version (7), Password
3. Click Create

Redis Connection

redis://:your-password@redis-cache:6379

const redis = new Redis({
  host: 'redis-cache',
  port: 6379,
  password: process.env.REDIS_PASSWORD
});

import redis
r = redis.Redis(host='redis-cache', port=6379, password=os.environ['REDIS_PASSWORD'])

Redis for Different Use Cases

Consider separate Redis instances for different purposes:

For document-based storage or when your app requires MongoDB specifically.

1. Add Resource → Database → MongoDB
2. Configure: Name (mongo-main), Version (7), Root Username, Root Password
3. Click Create

MongoDB Connection

mongodb://admin:password@mongo-main:27017/app_production?authSource=admin

mongoose.connect(process.env.MONGODB_URL);

client = MongoClient(os.environ['MONGODB_URL'])

Data without backups is data waiting to be lost. Coolify provides automated backup scheduling with multiple destination options.

Enable Scheduled Backups

1. Go to your database resource → Backups
2. Click Add Backup
3. Configure the schedule (see table below)

Backup Verification

Periodically test your backups:

# Spin up a temporary container
docker run -d --name test-restore -e POSTGRES_PASSWORD=test postgres:16
docker cp backup.sql test-restore:/backup.sql
docker exec test-restore psql -U postgres -f /backup.sql
docker exec test-restore psql -U postgres -c "SELECT COUNT(*) FROM users;"
docker rm -f test-restore

Sometimes you need to connect directly—running migrations, using a GUI client, or debugging.

ssh -L 5432:postgres-main:5432 root@your-server-ip

Most frameworks include migration tools. Run them either during deployment or manually.

# Node.js (Prisma)
npx prisma migrate deploy

# Python (Alembic)
alembic upgrade head

# Laravel
php artisan migrate --force

# Rails
rails db:migrate

# SSH to your server
ssh root@your-server-ip

# Execute command in your app's container
docker exec -it <app-container-id> npx prisma migrate deploy