appliku.yml Configuration

The appliku.yml file is a YAML configuration file that defines how your application should be built, deployed, and configured in Appliku. Place this file in the root directory of your application repository.

To verify the configuration, go to the application settings page, "YAML Config" tab.

You can specify a different file for configuration, which is convenient for production/non-production environments running different sets of commands.

Example

You can check out an example in the SpeedPy boilerplate: appliku.yml

Root Level Structure

The configuration file contains the following top-level sections:

• build_settings — Application build configuration
• services — Application processes/services
• databases — Database services
• volumes — Persistent storage volumes
• cronjobs — Scheduled tasks

Build Settings

The build_settings section configures how your application is built and prepared for deployment.

Required Fields

• build_image (string) — The buildpack or runtime environment to use

Optional Fields

• build_command (string) — Command to run during the build phase
• dockerfile (string) — Custom Dockerfile content (when using dockerfile or custom build_image)
• dockerfile_path (string) — Path to Dockerfile in repository (default: "Dockerfile")
• dockerfile_context_path (string) — Build context path for Dockerfile
• container_port (integer) — Port your application listens on inside the container
• skip_release_command (boolean) — Skip running release command after deployment (default: false)
• expose_web_port (boolean) — Expose container port on all interfaces (default: false)
• is_static_site (boolean) — Mark application as static site (default: false)
• output_directory (string) — Directory containing built static files
• environment_variables (array) — Environment variables for the application

Available Build Images

Python Runtimes:

• python-3.13, python-3.12, python-3.11, python-3.10

Python + Node.js Runtimes:

• python-3.13-node-20.18, python-3.12-node-20.10, python-3.11-node-20.10, python-3.10-node-20.10

Ruby Runtimes:

• ruby-3.4.1, ruby-3.3-rails

Node.js Runtimes:

• node-20-npm, node-20-yarn, node-14

Alternative Runtimes:

• pypy2, pypy3

Custom:

• dockerfile — Use Dockerfile from codebase
• custom — Custom Dockerfile entered in the dashboard

See Predefined Dockerfiles for the full Dockerfile contents of each build image.

Environment Variables

Environment variables can be configured in four ways:

1. Static Value:

environment_variables:
  - name: MY_ENV_VAR
    value: my_value

2. From Database (public connection):

environment_variables:
  - name: DATABASE_URL
    from_database:
      name: db
      property: connection_url

3. From Database (private/internal connection):

environment_variables:
  - name: DATABASE_URL
    from_database:
      name: db
      property: private_connection_url

4. From Domains:

Sets the variable to a comma-separated list of all domains added to the application, including the default .applikuapp.com subdomain if enabled.

environment_variables:
  - name: ALLOWED_HOSTS
    from_domains: true

5. Manual Configuration:

Documents that a variable is supposed to be set by the user. It will be present with an empty value in the list of environment variables in the dashboard.

environment_variables:
  - name: OPENAI_API_KEY
    source: manual

Services

The services section defines the processes that run your application. Each service is a key-value pair where the key is the service name and the value contains the service configuration.

Service Configuration Fields

• command (string) — Command to run the service
• scale (integer) — Number of instances to run (default: 1)
• mode (string) — Service mode: replicated or global (default: "replicated")
• placement_constraints (string) — Docker Swarm placement constraints
• resources_limits_memory (string) — Memory limits (e.g., "512M", "2G")
• resources_limits_cpus (string) — CPU limits (e.g., "0.5", "2")
• resources_reservations_memory (string) — Memory reservations
• resources_reservations_cpus (string) — CPU reservations
• image — Use an existing image (e.g., from Docker Hub)
• volumes — List of Docker volumes
• shm_size — Shared memory size
• ports — Port mappings between host and containers
• mem_limit — Memory limit for the container

See Docker Services Specification and Docker Deploy Specification for more details.

Example Services

services:
  web:
    command: gunicorn project.wsgi --log-file -
    scale: 1
    mode: replicated
    resources_limits_memory: 512M
    resources_limits_cpus: "0.5"

  worker:
    command: celery -A project worker -l info
    scale: 2
    mode: replicated

  release:
    command: bash release.sh

Databases

The databases section defines database services that will be provisioned for your application.

Available Database Types

Type	Key
PostgreSQL 17	postgresql_17
PostgreSQL 16	postgresql_16
PostgreSQL 15	postgresql_15
PostgreSQL 12	postgresql_12
PostGIS 16 + 3.4	postgis_16_34
PostgreSQL 16 + pgvector	postgresql_16_pgvector
TimescaleDB 15	timescale_db_15
MySQL 8	mysql_8
Redis 7	redis_7
Redis 6	redis_6
RabbitMQ	rabbitmq
Elasticsearch 8.17	elasticsearch_8_17

Example Databases

databases:
  db:
    type: postgresql_17
  redis:
    type: redis_7

Volumes

The volumes section defines persistent storage volumes for your application.

Volume Configuration Fields

• target (string, required) — Path inside the container where volume is mounted
• url (string, optional) — URL path for web access to volume
• environment_variable (string, optional) — Environment variable name for volume path
• source (string, optional) — Source path on host (for bind mounts)

Example Volumes

volumes:
  media:
    target: /uploads/
    url: /media/
    environment_variable: MEDIA
  data:
    target: /app/data/
    environment_variable: DATA_PATH

Cron Jobs

The cronjobs section defines scheduled tasks that run at specified intervals.

Cron Job Configuration Fields

• schedule (string, required) — Cron schedule expression
• command (string, required) — Command to execute

Example Cron Jobs

cronjobs:
  send_emails:
    schedule: "0 * * * *"  # Every hour
    command: python manage.py send_emails
  daily_backup:
    schedule: "0 2 * * *"  # Daily at 2 AM
    command: python manage.py backup

Using the Configuration

Validation

The configuration file is automatically validated when:

• You push code to your repository
• You manually trigger a deployment
• You import the configuration through the Appliku dashboard

Configuration Updates

When you update the appliku.yml file and push to your repository, Appliku will:

1. Validate the new configuration
2. Apply the changes to your application
3. Deploy the updated configuration

Exporting Configuration

You can export the current application configuration as an appliku.yml file from the Appliku dashboard.

Go to the application settings page, "YAML Config" tab, and click "Export YAML Config". You can then copy the contents to the clipboard or download it as an appliku.yml file and save it to your application repository.

Complete Example

build_settings:
  build_image: python-3.11-node-20.10
  build_command: npm run build
  container_port: 8000
  environment_variables:
    - name: DEBUG
      value: "false"
    - name: DATABASE_URL
      from_database:
        name: db
        property: connection_url
    - name: REDIS_URL
      from_database:
        name: redis
        property: connection_url
    - name: ALLOWED_HOSTS
      from_domains: true
    - name: SECRET_KEY
      source: manual

services:
  web:
    command: gunicorn project.wsgi --log-file -
    scale: 2
  worker:
    command: celery -A project worker -l info
    scale: 1
  release:
    command: python manage.py migrate

databases:
  db:
    type: postgresql_17
  redis:
    type: redis_7

volumes:
  media:
    target: /app/media/
    url: /media/
    environment_variable: MEDIA_ROOT

cronjobs:
  cleanup:
    schedule: "0 3 * * *"
    command: python manage.py cleanup_old_files