Skip to main content

​
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

1

Navigate to Templates

In the Dokploy dashboard:
  1. Go to your project
  2. Click Create Service
  3. Select Template
2

Choose a Template

Browse available templates or search by name/category.
3

Configure

Most templates require minimal configuration:
  • Name: A unique identifier
  • Environment Variables: Database credentials, admin passwords
  • Domain: Optional custom domain
4

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"
  }'

​
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
  • 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}
After deployment:
  1. Access http://your-domain:8090/_/
  2. Create your admin account
  3. Start building your collections
  4. 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:
  1. Navigate to your deployed template
  2. Go to Advanced → Compose File
  3. Edit the YAML configuration
  4. Click Save and Redeploy

​
Common Customizations

Add a domain to any service:
  1. Go to Domains tab
  2. Click Add Domain
  3. Enter your domain name
  4. Select SSL type (Let’s Encrypt recommended)
  5. Click Create
Add resource limits in the compose file:
services:
  app:
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2G
Persist additional data:
services:
  app:
    volumes:
      - app_uploads:/app/uploads
      - app_config:/app/config

volumes:
  app_uploads:
  app_config:
Enable automated backups for template databases:
  1. Navigate to the database service
  2. Go to Backups
  3. Configure schedule and destination
  4. Click Enable

​
Creating Custom Templates

You can create your own templates for reuse:
1

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}
2

Add to Dokploy

Deploy as a regular Docker Compose application in Dokploy.
3

Export Configuration

Once configured and tested:
  1. Go to Advanced → Compose File
  2. Copy the final configuration
  3. 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

​
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

1

Backup Data

Use Dokploy’s backup feature or manual export:
docker exec postgres pg_dump -U user database > backup.sql
2

Backup Configuration

Export the compose file and environment variables
3

Restore

Redeploy the template and restore data:
docker exec -i postgres psql -U user database < backup.sql

​
Troubleshooting

  • Check Dokploy logs for error messages
  • Verify all required environment variables are set
  • Ensure sufficient resources (CPU, memory, disk)
  • Check Docker image availability
  • 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
  • Wait for database to fully initialize (check logs)
  • Verify database credentials match
  • Check DATABASE_URL format
  • Ensure database service is healthy
  • 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

Build docs developers (and LLMs) love

Get started for freeTalk to us