> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devset.io/llms.txt
> Use this file to discover all available pages before exploring further.

# How to Install Devset: Docker and Source Build Options

> Install Devset using Docker for the fastest setup, or build the backend and frontend from source for local development and contribution.

Devset ships as a single Docker image that bundles the Spring Boot backend and the frontend together. For most users the Docker path is the fastest and most reliable way to get running. If you want to contribute to Devset or customize the build, the from-source instructions below have you covered.

<Info>
  **System requirements:** A machine running Linux, macOS, or Windows with Docker installed. The Devset container requires at least 512 MB of available memory. For building from source you also need Java 25+ and Node.js 22+.
</Info>

## Option 1: Docker (recommended)

### Basic setup

Pull and start the latest Devset Community Edition image with a single command:

```bash theme={null}
docker run -p 8082:8082 -v devset-data:/data ghcr.io/devset-io/devset-ce:latest
```

Then open [http://localhost:8082](http://localhost:8082) in your browser.

| Flag                   | Purpose                                                |
| ---------------------- | ------------------------------------------------------ |
| `-p 8082:8082`         | Maps container port 8082 to your host on the same port |
| `-v devset-data:/data` | Persists all application data in a named Docker volume |

<Note>
  To run Devset on a different host port — for example `9090` — change the left side of the port mapping: `-p 9090:8082`. Devset itself always listens on `8082` inside the container.
</Note>

### Docker Compose with Kafka and RabbitMQ

If you don't already have broker infrastructure running locally, use the following Compose file to bring up Kafka, RabbitMQ, and Devset together as a single stack.

```yaml docker-compose.yml theme={null}
services:
  kafka:
    image: confluentinc/cp-kafka:7.9.0
    environment:
      KAFKA_NODE_ID: 1
      KAFKA_PROCESS_ROLES: broker,controller
      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@kafka:9093
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092,CONTROLLER://kafka:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,CONTROLLER:PLAINTEXT
      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      CLUSTER_ID: devset-local-cluster-01
    ports:
      - "9092:9092"

  rabbitmq:
    image: rabbitmq:4.1-management
    environment:
      RABBITMQ_DEFAULT_USER: guest
      RABBITMQ_DEFAULT_PASS: guest
    ports:
      - "5672:5672"
      - "15672:15672"

  devset:
    image: ghcr.io/devset-io/devset-ce:latest
    depends_on:
      - kafka
      - rabbitmq
    ports:
      - "8082:8082"
    volumes:
      - devset-data:/data

volumes:
  devset-data:
```

Start the full stack:

```bash theme={null}
docker compose up -d
```

Once running, open Devset at [http://localhost:8082](http://localhost:8082) and add your connectors in **Settings**:

* **Kafka bootstrap server:** `kafka:9092` (from within the Compose network) or `localhost:9092` (from your host)
* **RabbitMQ host:** `rabbitmq` (from within the Compose network) or `localhost` (from your host)

### Environment variables

You can configure Devset's server binding at startup using standard Spring Boot environment variable overrides:

| Variable      | Default | Description                                     |
| ------------- | ------- | ----------------------------------------------- |
| `SERVER_PORT` | `8082`  | The port Devset listens on inside the container |

Pass environment variables to the container with the `-e` flag:

```bash theme={null}
docker run -p 9000:9000 -e SERVER_PORT=9000 \
  -v devset-data:/data \
  ghcr.io/devset-io/devset-ce:latest
```

***

## Option 2: Build from source

Build Devset from source when you want to modify the codebase, run the test suite, or develop new features.

### Prerequisites

Before you begin, make sure the following are installed and available on your `PATH`:

* **Java 25 or later** — the Devset backend is a Spring Boot application built with Gradle
* **Node.js 22 or later** — the frontend is built with a Node-based toolchain
* **Docker** — required to run the Docker image or the end-to-end test suite

### Start the backend

```bash theme={null}
cd devset-ce-be
./gradlew bootRun --args='--spring.profiles.active=dev'
```

The backend starts on port `8082`. With the `dev` profile active, Devset uses a local SQLite database instead of the default data directory.

<Note>
  In `dev` mode the SQLite database is created at `devset-ce-be/data/devset.db`. You can inspect or reset it directly using any SQLite client. Delete the file to start with a clean database on the next run.
</Note>

### Start the frontend

Open a second terminal and run:

```bash theme={null}
cd devset-ce-fe
npm install
npm run dev
```

The frontend development server starts on **port 5173** and proxies API requests to the backend on port `8082`. Open [http://localhost:5173](http://localhost:5173) in your browser during development.

<Warning>
  In dev mode, always access the UI on port **5173** — not `8082`. The hot-reload dev server runs on 5173, and accessing port 8082 directly will bypass frontend hot-reloading.
</Warning>

***

## What's next?

Once Devset is up and running, head to the [Quickstart guide](/quickstart) to connect a broker and send your first message.