One-Click Templates

Overview

Dokploy provides a curated collection of one-click templates that allow you to deploy popular open-source applications with minimal configuration. Templates are pre-configured Docker Compose stacks optimized for production use.

Quick Setup

Deploy complex stacks in seconds

Best Practices

Pre-configured with security and performance optimizations

Customizable

Easily modify configuration after deployment

Available Templates

Dokploy includes templates for:

Analytics: Plausible, Umami, Matomo
CMS: WordPress, Ghost, Strapi
Databases: PostgreSQL, MySQL, MongoDB with management UIs
Development Tools: Gitea, Code Server, Jupyter
Project Management: Plane, Taiga
Communication: Rocket.Chat, Mattermost
Backend Services: Supabase, Appwrite, PocketBase
Monitoring: Grafana, Prometheus, Uptime Kuma
And many more

Deploying a Template

Navigate to Templates

In the Dokploy dashboard:

Go to your project
Click Create Service
Select Template

Choose a Template

Browse available templates or search by name/category.

Configure

Most templates require minimal configuration:

Name: A unique identifier
Environment Variables: Database credentials, admin passwords
Domain: Optional custom domain

Deploy

Click Deploy and Dokploy will:

Pull required Docker images
Create necessary volumes
Configure networking
Start all services

Using the API

Deploy templates programmatically:

List Available Templates

curl https://your-dokploy-instance.com/api/compose.templates \
  -H "Authorization: Bearer YOUR_API_KEY"

Deploy from Template

curl -X POST https://your-dokploy-instance.com/api/compose.deployFromTemplate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "composeId": "compose-id",
    "templateName": "plausible"
  }'

Popular Templates

Plausible Analytics

Privacy-focused web analytics:

services:
  plausible:
    image: plausible/analytics:latest
    ports:
      - "8000:8000"
    environment:
      - BASE_URL=https://analytics.example.com
      - SECRET_KEY_BASE=${SECRET_KEY_BASE}
      - DATABASE_URL=postgres://postgres:${POSTGRES_PASSWORD}@db:5432/plausible
      - CLICKHOUSE_DATABASE_URL=http://clickhouse:8123/plausible

Configuration Options

BASE_URL: Your Plausible instance URL
SECRET_KEY_BASE: Random 64-character string for encryption
DISABLE_REGISTRATION: Set to “true” to disable new signups
GOOGLE_CLIENT_ID / GOOGLE_CLIENT_SECRET: For Google Search Console integration

PocketBase

Open-source backend in a single file:

services:
  pocketbase:
    image: ghcr.io/muchobien/pocketbase:latest
    ports:
      - "8090:8090"
    volumes:
      - pocketbase_data:/pb/pb_data
    command:
      - --encryptionEnv=PB_ENCRYPTION_KEY
    environment:
      - PB_ENCRYPTION_KEY=${ENCRYPTION_KEY}

Getting Started

After deployment:

Access http://your-domain:8090/_/
Create your admin account
Start building your collections
Use the auto-generated REST/Realtime API

Supabase

Open-source Firebase alternative:

services:
  studio:
    image: supabase/studio:latest
    ports:
      - "3000:3000"
    environment:
      - SUPABASE_URL=http://kong:8000
      - SUPABASE_ANON_KEY=${ANON_KEY}
      - SUPABASE_SERVICE_KEY=${SERVICE_KEY}
  
  kong:
    image: kong:2.8.1
    ports:
      - "8000:8000"
  
  auth:
    image: supabase/gotrue:latest
    environment:
      - GOTRUE_SITE_URL=${SITE_URL}
      - GOTRUE_JWT_SECRET=${JWT_SECRET}
  
  db:
    image: supabase/postgres:15
    volumes:
      - supabase_db:/var/lib/postgresql/data

Supabase templates include: PostgreSQL, Auth, Storage, Realtime, and Studio UI.

Gitea

Lightweight self-hosted Git service:

services:
  gitea:
    image: gitea/gitea:latest
    ports:
      - "3000:3000"
      - "22:22"
    volumes:
      - gitea_data:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - GITEA__database__DB_TYPE=postgres
      - GITEA__database__HOST=db:5432
      - GITEA__database__NAME=gitea
      - GITEA__database__USER=gitea
      - GITEA__database__PASSWD=${DB_PASSWORD}

Customizing Templates

After deploying a template, you can customize it:

Via Dashboard
Via API

Navigate to your deployed template
Go to Advanced → Compose File
Edit the YAML configuration
Click Save and Redeploy

curl -X POST https://your-dokploy-instance.com/api/compose.update \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "composeId": "compose-id",
    "composeFile": "version: \"3.8\"\nservices:..."
  }'

Common Customizations

Add Custom Domain

Add a domain to any service:

Go to Domains tab
Click Add Domain
Enter your domain name
Select SSL type (Let’s Encrypt recommended)
Click Create

Increase Resources

Add resource limits in the compose file:

services:
  app:
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2G

Add Volumes

Persist additional data:

services:
  app:
    volumes:
      - app_uploads:/app/uploads
      - app_config:/app/config

volumes:
  app_uploads:
  app_config:

Configure Backups

Enable automated backups for template databases:

Navigate to the database service
Go to Backups
Configure schedule and destination
Click Enable

Creating Custom Templates

You can create your own templates for reuse:

Prepare Docker Compose

Create a docker-compose.yml with your stack:

version: "3.8"
services:
  app:
    image: myapp:latest
    environment:
      - DATABASE_URL=${DATABASE_URL}
  db:
    image: postgres:16
    environment:
      - POSTGRES_PASSWORD=${DB_PASSWORD}

Add to Dokploy

Deploy as a regular Docker Compose application in Dokploy.

Export Configuration

Once configured and tested:

Go to Advanced → Compose File
Copy the final configuration
Save as a template for future use

Share your templates with the Dokploy community by contributing to the templates repository.

Template Best Practices

Use Environment Variables

Parameterize all secrets and configuration for reusability

Include Health Checks

Add health checks for automatic recovery

Set Resource Limits

Prevent resource exhaustion with limits

Use Named Volumes

Ensure data persistence across redeployments

Managing Template Deployments

Updating

Update template deployments to newer versions:

docker-compose pull
docker-compose up -d

# Click "Redeploy" in the dashboard
# or use the API:
curl -X POST https://your-dokploy-instance.com/api/compose.redeploy \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"composeId": "compose-id"}'

Monitoring

Monitor template deployments:

Logs: View real-time logs for each service
Metrics: CPU, memory, network usage per container
Health Status: Automatic health check monitoring

Backup and Restore

Backup Data

Use Dokploy’s backup feature or manual export:

docker exec postgres pg_dump -U user database > backup.sql

Backup Configuration

Export the compose file and environment variables

Restore

Redeploy the template and restore data:

docker exec -i postgres psql -U user database < backup.sql

Troubleshooting

Template fails to deploy

Check Dokploy logs for error messages
Verify all required environment variables are set
Ensure sufficient resources (CPU, memory, disk)
Check Docker image availability

Services can't communicate

Verify services are on the same Docker network
Check service names match in connection strings
Review compose file network configuration
Ensure ports are not conflicting

Database connection errors

Wait for database to fully initialize (check logs)
Verify database credentials match
Check DATABASE_URL format
Ensure database service is healthy

Domain/SSL not working

Verify DNS points to your server
Check Traefik configuration
Review domain settings in Dokploy
Check port mappings in compose file

Next Steps

Docker Compose

Learn more about Docker Compose in Dokploy

Domains & SSL

Configure custom domains for templates

Backups

Set up automated backups

Monitoring

Monitor your template deployments

​Overview

Quick Setup

Best Practices

Customizable

​Available Templates

​Deploying a Template

​Using the API

​Popular Templates

​Plausible Analytics

​PocketBase

​Supabase

​Gitea

​Customizing Templates

​Common Customizations

​Creating Custom Templates

​Template Best Practices

Use Environment Variables

Include Health Checks

Set Resource Limits

Use Named Volumes

​Managing Template Deployments

​Updating

​Monitoring

​Backup and Restore

​Troubleshooting

​Next Steps

Docker Compose

Domains & SSL

Backups

Monitoring

Overview

Available Templates

Deploying a Template

Using the API

Popular Templates

Plausible Analytics

PocketBase

Supabase

Gitea

Customizing Templates

Common Customizations

Creating Custom Templates

Template Best Practices

Managing Template Deployments

Updating

Monitoring

Backup and Restore

Troubleshooting

Next Steps