Self-Hosting Bar Assistant with Docker Compose

What Is Bar Assistant?

Bar Assistant is a self-hosted cocktail recipe manager that comes pre-loaded with 500+ cocktail recipes and 250+ base ingredients. It tracks your home bar inventory, suggests cocktails you can make with what you have, calculates costs, and supports multi-user access with role-based permissions. Think of it as your personal bartending companion — all the recipes, none of the subscription fees.

• Official site: barassistant.app
• Source code: github.com/karlomikus/bar-assistant
• License: MIT

Prerequisites

• A Linux server (Ubuntu 22.04+ recommended)
• Docker and Docker Compose installed (guide)
• 1 GB of free RAM
• 2 GB of free disk space
• A domain name (optional, for remote access)

Docker Compose Configuration

Bar Assistant requires three services: the API server (PHP/Laravel), Redis for caching, and Meilisearch for full-text search.

Create a docker-compose.yml file:

services:
  bar-assistant:
    image: barassistant/server:v5.13.1
    container_name: bar-assistant
    ports:
      - "8000:80"
    environment:
      APP_ENV: "production"
      APP_KEY: "${APP_KEY}"
      APP_URL: "${APP_URL}"
      APP_DEBUG: "false"
      LOG_LEVEL: "warning"

      # Database (SQLite, embedded)
      DB_CONNECTION: "sqlite"
      DB_FOREIGN_KEYS: "true"

      # Redis (required for caching and sessions)
      CACHE_DRIVER: "redis"
      SESSION_DRIVER: "redis"
      REDIS_HOST: "redis"
      REDIS_PORT: "6379"

      # Meilisearch (required for recipe search)
      SCOUT_DRIVER: "meilisearch"
      MEILISEARCH_HOST: "http://meilisearch:7700"
      MEILISEARCH_KEY: "${MEILI_MASTER_KEY}"

      # Email (optional)
      MAIL_FROM_ADDRESS: "[email protected]"
      MAIL_FROM_NAME: "Bar Assistant"
    volumes:
      - bar-data:/var/www/cocktails/storage/bar-assistant
    depends_on:
      - redis
      - meilisearch
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    container_name: bar-assistant-redis
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3

  meilisearch:
    image: getmeili/meilisearch:v1.11
    container_name: bar-assistant-search
    environment:
      MEILI_NO_ANALYTICS: "true"
      MEILI_MASTER_KEY: "${MEILI_MASTER_KEY}"
    volumes:
      - meili-data:/meili_data
    restart: unless-stopped

volumes:
  bar-data:
  meili-data:

Create a .env file alongside:

# Application URL (no trailing slash)
APP_URL=http://localhost:8000

# Application key — generate with: echo "base64:$(openssl rand -base64 32)"
APP_KEY=base64:change_me_generate_a_real_key

# Meilisearch master key — generate with: openssl rand -hex 16
MEILI_MASTER_KEY=change_me_to_a_strong_random_key

Start the stack:

docker compose up -d

Initial Setup

1. Wait 30-60 seconds for database migrations and initial data seeding (500+ cocktail recipes are imported automatically)
2. Open http://your-server-ip:8000 in your browser
3. Create your first admin account through the registration page
4. Start exploring the pre-loaded cocktail database
5. Add your home bar ingredients to see which cocktails you can make

Note: Bar Assistant is an API-only backend. For a web interface, deploy the Salt Rim frontend alongside it, or use the API directly.

Configuration

Salt Rim Web Frontend

Bar Assistant serves the API. For a full web experience, add the Salt Rim frontend:

services:
  salt-rim:
    image: barassistant/salt-rim:v3
    container_name: bar-assistant-web
    ports:
      - "3000:8080"
    environment:
      API_URL: "http://bar-assistant"
      MEILISEARCH_URL: "http://meilisearch:7700"
    depends_on:
      - bar-assistant
    restart: unless-stopped

Access the web interface at http://your-server-ip:3000.

Home Bar Inventory

The killer feature: tell Bar Assistant what ingredients you have, and it shows which cocktails you can make:

1. Go to My Shelf in Salt Rim
2. Add your spirits, liqueurs, mixers, and garnishes
3. The dashboard updates to show cocktails you can make with your current inventory
4. Filter by “shelf cocktails” to see only what’s possible right now

Custom Recipes

Add your own recipes through the API or Salt Rim:

1. Click Add Cocktail
2. Enter the name, method, garnish, and ingredients with measurements
3. Upload a photo (optional)
4. Tag with categories and glass type
5. The recipe is immediately searchable via Meilisearch

Role-Based Access

Bar Assistant supports multiple users with different permission levels:

Role	Can View	Can Create	Can Manage
Guest	Public recipes only	No	No
User	All recipes	Own recipes	Own recipes
Moderator	All recipes	All recipes	All recipes
Admin	All recipes	All recipes	All + users + settings

Reverse Proxy

For SSL and external access, place both the API (port 8000) and Salt Rim frontend (port 3000) behind a reverse proxy. With Nginx Proxy Manager, create two proxy hosts or use subpath routing.

See Reverse Proxy Setup for configuration guides.

Backup

All recipe data is stored in SQLite within the application volume:

# Back up the data volume
docker run --rm -v bar-data:/data -v $(pwd):/backup alpine tar czf /backup/bar-assistant-$(date +%Y%m%d).tar.gz -C /data .

# Back up Meilisearch index (optional — can be rebuilt)
docker run --rm -v meili-data:/data -v $(pwd):/backup alpine tar czf /backup/meili-$(date +%Y%m%d).tar.gz -C /data .

See Backup Strategy.

Troubleshooting

Search not returning results

Symptom: Typing in the search bar returns no results despite having recipes.

Fix: Meilisearch may not have indexed the recipes. Check the Meilisearch container is running: docker compose logs meilisearch. If it crashed, restart it and the indexing will resume. Verify MEILI_MASTER_KEY matches between Bar Assistant and Meilisearch environment variables.

APP_KEY errors on startup

Symptom: Container logs show “No application encryption key has been specified.”

Fix: Generate a valid APP_KEY:

echo "base64:$(openssl rand -base64 32)"

Set this value in your .env file and restart.

Images not loading in Salt Rim

Symptom: Recipe photos show as broken images in the web frontend.

Fix: Ensure API_URL in Salt Rim’s environment matches the actual URL of the Bar Assistant API. If using a reverse proxy, the URL must be the public-facing URL, not the internal Docker service name.

Resource Requirements

• RAM: 300 MB (API) + 100 MB (Redis) + 200 MB (Meilisearch) = ~600 MB total
• CPU: Low — Laravel API with SQLite is lightweight
• Disk: 1 GB for application + recipes, plus Meilisearch index (~200 MB)

Verdict

Bar Assistant is the best self-hosted cocktail recipe manager by a wide margin. The pre-loaded database of 500+ recipes means you’re immediately useful out of the box — no data entry needed. The home bar inventory feature that shows “what can I make right now?” is genuinely useful for anyone who mixes drinks regularly. The main downside is the three-service architecture (API + Redis + Meilisearch) which is heavier than necessary for a recipe app, and you need to deploy Salt Rim separately for a web interface. But for cocktail enthusiasts, it’s worth the setup.

Related

• Best Self-Hosted Recipe Managers
• How to Self-Host Mealie
• How to Self-Host Tandoor
• How to Self-Host Recipya
• How to Self-Host KitchenOwl
• Self-Hosted Alternatives to Paprika
• Docker Compose Basics
• Reverse Proxy Setup
• Backup Strategy