Templates

Deploy pre-configured apps with one click.

Available Templates

Databases

Template	Description	Default Port
PostgreSQL	Relational database	5432
MySQL	Popular SQL database	3306
MariaDB	MySQL-compatible	3306
MongoDB	Document database	27017
Redis	In-memory cache	6379

Database Admin

Template	Description	Default Port
pgAdmin	PostgreSQL admin UI	80
phpMyAdmin	MySQL/MariaDB admin	80
Adminer	Universal DB admin	8080
RedisInsight	Redis GUI	8001

Web Servers

Template	Description	Default Port
Nginx	Static file server	80
Apache	HTTP server	80
Caddy	Modern web server	80

CMS

Template	Description	Default Port
WordPress	Blog/CMS platform	80
Ghost	Modern publishing	2368
Strapi	Headless CMS	1337

Development Tools

Template	Description	Default Port
Gitea	Git server	3000
Code Server	VS Code in browser	8080
Portainer	Container management	9000
n8n	Workflow automation	5678

Monitoring

Template	Description	Default Port
Uptime Kuma	Status monitoring	3001
Grafana	Metrics dashboard	3000
Prometheus	Metrics collection	9090

Storage

Template	Description	Default Port
MinIO	S3-compatible storage	9000
File Browser	Web file manager	80

Using Templates

Via Dashboard

1. Open Basepod dashboard
2. Go to Templates
3. Click on a template
4. Enter app name
5. Click Deploy

Via CLI

# List templates
bp templates

# Deploy from template
bp deploy mydb --template postgres

Template Configuration

Each template includes sensible defaults. You can customize:

• Name: Your app name (becomes subdomain)
• Environment Variables: Pre-filled with defaults
• Volumes: Persistent storage paths

Example: PostgreSQL

Default environment:

POSTGRES_USER: postgres
POSTGRES_PASSWORD: (generated)
POSTGRES_DB: postgres

Default volume:

/var/lib/postgresql/data

Example: WordPress

Default environment:

WORDPRESS_DB_HOST: (your-db-container)
WORDPRESS_DB_USER: wordpress
WORDPRESS_DB_PASSWORD: (generated)
WORDPRESS_DB_NAME: wordpress

Connecting Apps

Templates that need databases can connect via internal networking.

1. Deploy a database (e.g., PostgreSQL)
2. Deploy your app
3. Use the internal hostname: basepod-postgres:5432

Example WordPress + MySQL:

# Deploy MySQL
bp deploy mydb --template mysql

# Deploy WordPress
bp deploy myblog --template wordpress

# In WordPress config, use:
# DB_HOST=basepod-mydb:3306

Creating Custom Templates

Create your own templates for single apps or multi-service stacks.

Template File Structure

Create a .yaml file with your template definition:

# mytemplate.yaml
name: myapp
version: "1.0"

services:
  - name: web
    image: nginx:alpine
    port: 80
    env:
      NGINX_HOST: example.com
    volumes:
      - html:/usr/share/nginx/html

Deploy Custom Template

# Deploy local template file
bp template deploy ./mytemplate.yaml

# Deploy with custom name
bp template deploy ./mytemplate.yaml --name mysite

---

Multi-Service Stacks

Define multiple services in one template, similar to docker-compose.

Example: Node.js + PostgreSQL

# nodeapp.yaml
name: nodeapp
version: "1.0"

services:
  - name: api
    build: .
    port: 3000
    env:
      DATABASE_URL: postgres://postgres:secret@db:5432/app
      NODE_ENV: production
    depends_on:
      - db

  - name: db
    template: postgres
    env:
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: app
    volumes:
      - pgdata:/var/lib/postgresql/data

Example: WordPress Stack

# wordpress-stack.yaml
name: myblog
version: "1.0"

services:
  - name: wordpress
    template: wordpress
    port: 80
    env:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: secret
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wp-content:/var/www/html/wp-content
    depends_on:
      - db

  - name: db
    template: mysql
    env:
      MYSQL_ROOT_PASSWORD: rootsecret
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: secret
    volumes:
      - mysql-data:/var/lib/mysql

Example: LAMP Stack

# lamp.yaml
name: lamp
version: "1.0"

services:
  - name: web
    image: php:8.2-apache
    port: 80
    env:
      DB_HOST: db
      DB_NAME: app
    volumes:
      - ./src:/var/www/html
    depends_on:
      - db

  - name: db
    template: mysql
    env:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: app
    volumes:
      - mysql-data:/var/lib/mysql

  - name: phpmyadmin
    template: phpmyadmin
    port: 8080
    env:
      PMA_HOST: db

---

Template Schema Reference

Root Fields

Field	Type	Required	Description
name	string	Yes	Stack name (used as prefix)
version	string	No	Template version
services	array	Yes	List of services

Service Fields

Field	Type	Required	Description
name	string	Yes	Service name
image	string	No*	Docker image
template	string	No*	Use predefined template
build	string	No*	Build from path
port	integer	No	Exposed port
env	object	No	Environment variables
volumes	array	No	Volume mounts
depends_on	array	No	Service dependencies

*One of image, template, or build is required.

Service Types

1. From Docker Image

- name: web
  image: nginx:alpine
  port: 80

2. From Predefined Template

- name: db
  template: postgres
  env:
    POSTGRES_PASSWORD: secret

3. From Local Source

- name: api
  build: ./api
  port: 3000

Volumes

Named volumes for persistence:

volumes:
  - data:/app/data           # named volume
  - ./local:/container/path  # bind mount (dev only)

Dependencies

Control startup order:

services:
  - name: api
    depends_on:
      - db
      - cache

  - name: db
    template: postgres

  - name: cache
    template: redis

---

Sharing Templates

Export Running Stack

# Export current app configuration as template
bp template export myapp > myapp-template.yaml

Template Library

Store templates in a git repository:

my-templates/
├── stacks/
│   ├── lamp.yaml
│   ├── mean.yaml
│   └── wordpress.yaml
└── apps/
    ├── api-server.yaml
    └── static-site.yaml

Deploy from URL:

bp template deploy https://github.com/user/templates/raw/main/stacks/lamp.yaml

---

Environment Variables

Inline Values

env:
  NODE_ENV: production
  API_KEY: mysecret

Reference Other Services

Use service names as hostnames:

services:
  - name: api
    env:
      DATABASE_URL: postgres://user:pass@db:5432/mydb
      REDIS_URL: redis://cache:6379

  - name: db
    template: postgres

  - name: cache
    template: redis

Generated Values

Use placeholders for auto-generated values:

env:
  SECRET_KEY: ${RANDOM_32}      # 32-char random string
  API_TOKEN: ${RANDOM_64}       # 64-char random string
  DB_PASSWORD: ${RANDOM_16}     # 16-char random string

---

Best Practices

1. Use named volumes for data persistence
2. Set depends_on for proper startup order
3. Use templates for standard services (postgres, redis, etc.)
4. Keep secrets in environment variables, not in the template file
5. Version your templates in git for reproducibility