# Can I Use Snipe-IT with Docker? Complete Setup and Configuration Guide

> Yes, use Snipe-IT with Docker for a streamlined asset management solution. Get the complete setup and configuration guide for production-ready Docker deployment.

- Repository: [Grokability, Inc./snipe-it](https://github.com/grokability/snipe-it)
- Tags: how-to-guide
- Published: 2026-07-31

---

**Yes, Snipe-IT fully supports Docker deployment with official images, production-ready Dockerfiles, and docker-compose configurations that allow you to run the complete asset management stack using containers.**

The `grokability/snipe-it` repository ships with first-class containerization support, including Alpine-based and FPM-based Dockerfiles alongside a production-grade [`docker-compose.yml`](https://github.com/grokability/snipe-it/blob/main/docker-compose.yml). These resources enable you to deploy Snipe-IT using pre-built images from Docker Hub or build custom images tailored to your infrastructure requirements.

## Snipe-IT Docker Architecture Overview

Snipe-IT’s Docker implementation separates the web application from the database using standard container orchestration patterns. The architecture consists of an **Apache + PHP container** running the Laravel application and a **MariaDB container** handling data persistence.

### The Alpine Dockerfile

The primary `Dockerfile.alpine` builds a lightweight image based on Alpine Linux that includes:

- **Apache web server** with `mod_rewrite` enabled to handle Snipe-IT’s URL routing requirements
- **PHP 8.4** with required extensions including `pdo_mysql`, `gd`, `zip`, and `mbstring`
- **Composer** for dependency management
- **Persistent volume** at `/var/lib/snipeit` for uploads, backups, and OAuth keys

According to the source code in `Dockerfile.alpine`, the build process configures Apache’s PID location, copies the application source to `/var/www/html`, and injects default environment variables from `docker/docker.env`. The container uses [`docker/startup_alpine.sh`](https://github.com/grokability/snipe-it/blob/main/docker/startup_alpine.sh) as its entrypoint to initialize Apache and run database migrations automatically on startup.

### Docker Compose Orchestration

The [`docker-compose.yml`](https://github.com/grokability/snipe-it/blob/main/docker-compose.yml) file defines two essential services:

1. **app**: Uses the `snipe/snipe-it:${APP_VERSION:-latest}` image and maps host port `${APP_PORT:-8000}` to container port 80
2. **db**: Runs `mariadb:11.4.7` with health checks to ensure the database is ready before the application starts

The compose configuration mounts a named `storage` volume to `/var/lib/snipeit`, ensuring that uploaded assets, backups, and keys survive container recreation. All database credentials and application settings are injected via environment variables from a `.env` file.

## Quick Start: Deploy Snipe-IT with Docker Compose

The fastest way to run Snipe-IT with Docker uses the provided compose file. This method automatically handles networking between the application and database containers.

1. Clone the repository and enter the directory:

```bash
git clone https://github.com/grokability/snipe-it.git
cd snipe-it

```

2. Create your environment configuration from the example file:

```bash
cp .env.example .env

```

Edit `.env` to set database credentials, application URL, and other required variables.

3. Start the container stack:

```bash
docker compose up -d

```

Once the containers report healthy status, access Snipe-IT at `http://localhost:8000` (or your configured `APP_PORT`) and complete the web-based installation wizard.

## Running Snipe-IT with Docker Run (Without Compose)

You can also run Snipe-IT directly using the official Docker Hub image without cloning the repository. This approach works well for testing or simplified deployments.

```bash
docker run -d \
  --name snipe-it \
  -p 8000:80 \
  -v snipeit-data:/var/lib/snipeit \
  --env-file .env \
  snipe/snipe-it:latest

```

This command creates a persistent named volume `snipeit-data` that stores user uploads, system backups, and OAuth encryption keys at `/var/lib/snipeit` inside the container. Ensure your `.env` file contains valid `DB_HOST`, `DB_DATABASE`, `DB_USERNAME`, and `DB_PASSWORD` values pointing to an accessible database server.

## Building Custom Snipe-IT Docker Images

For environments requiring specific PHP extensions or custom configurations, build your own image from the provided Dockerfiles. The repository includes two variants:

- **`Dockerfile.alpine`**: Apache-based image using mod_php (recommended for most users)
- **`Dockerfile.fpm-alpine`**: PHP-FPM-based image for use with external web servers like Nginx

To build a custom Alpine image with additional packages:

```bash

# In the repository root

docker build -f Dockerfile.alpine -t my-snipe-it:custom .

# Run your custom build

docker run -d -p 8000:80 --env-file .env my-snipe-it:custom

```

Modify the `apk add` instructions in `Dockerfile.alpine` to include system dependencies before the `RUN` commands that install PHP extensions. The build copies your local source code and applies the initialization logic from [`docker/startup_alpine.sh`](https://github.com/grokability/snipe-it/blob/main/docker/startup_alpine.sh).

## Data Persistence and Volume Management

Snipe-IT stores three categories of data that must persist beyond container lifecycles:

- **User uploads** (asset images, import files)
- **System backups** (database dumps generated by the application)
- **OAuth keys** (encryption keys for API authentication)

As implemented in `Dockerfile.alpine`, the container creates symlinks from `storage/private_uploads`, `public/uploads`, and `storage/app/backups` to `/var/lib/snipeit`. When you mount a volume to `/var/lib/snipeit`, these symlinks ensure the application continues writing to its expected local paths while actually persisting data to the host-managed volume.

The [`docker-compose.yml`](https://github.com/grokability/snipe-it/blob/main/docker-compose.yml) declares this as a named volume:

```yaml
volumes:
  storage:
    driver: local

```

For production deployments, consider mounting host directories or networked storage to `/var/lib/snipeit` rather than using anonymous volumes, enabling easier backup and migration strategies.

## Summary

- **Snipe-IT provides official Docker support** through the `grokability/snipe-it` repository with production-ready configurations
- **Two deployment methods** are available: pre-built images from Docker Hub (`snipe/snipe-it`) or building from `Dockerfile.alpine`/`Dockerfile.fpm-alpine`
- **Docker Compose** is the recommended approach, orchestrating the Apache/PHP application container with a MariaDB database container
- **Persistent storage** is handled through `/var/lib/snipeit` volumes that preserve uploads, backups, and OAuth keys across container restarts
- **Automatic initialization** occurs via [`docker/startup_alpine.sh`](https://github.com/grokability/snipe-it/blob/main/docker/startup_alpine.sh), which starts Apache and executes Laravel migrations when containers launch

## Frequently Asked Questions

### Can I use Snipe-IT with Docker in production?

Yes, the Docker implementation is production-ready. The [`docker-compose.yml`](https://github.com/grokability/snipe-it/blob/main/docker-compose.yml) uses specific MariaDB version tags (11.4.7) rather than floating tags, and the Alpine Dockerfile creates a hardened environment with persistent volume support. For production deployments, ensure you use named volumes or bind mounts for `/var/lib/snipeit`, configure proper environment variables in `.env`, and set up database backups outside the container.

### What database does Snipe-IT use with Docker?

The default [`docker-compose.yml`](https://github.com/grokability/snipe-it/blob/main/docker-compose.yml) configures a MariaDB 11.4.7 container as the database backend. The application connects using standard Laravel database configuration values passed through environment variables. You can also configure Snipe-IT to use an external MySQL or MariaDB server by modifying the `DB_HOST` variable in your `.env` file to point outside the container network.

### How do I upgrade Snipe-IT running in Docker?

To upgrade, pull the latest image tag (`snipe/snipe-it:latest`) or rebuild your custom image from the updated repository source, then restart the containers. The [`startup_alpine.sh`](https://github.com/grokability/snipe-it/blob/main/startup_alpine.sh) entrypoint automatically runs database migrations (`php artisan migrate`) during container startup, ensuring schema updates apply before the application serves traffic. Always backup your database and `/var/lib/snipeit` volume before upgrading.

### Where are uploaded files stored in the Snipe-IT Docker container?

Uploaded files are stored in `/var/lib/snipeit` inside the container, which maps to the Laravel application directories through symlinks created during the Docker build. Specifically, `storage/private_uploads`, `public/uploads`, and `storage/app/backups` are symlinked to subdirectories within `/var/lib/snipeit`. When using Docker Compose, this path is backed by the named `storage` volume, ensuring file persistence across container recreations.