# Deploying and Managing Swarm Nodes on the DAppNode Platform: A Complete Guide

> Deploy and manage Swarm nodes on DAppNode effortlessly. Install the official Swarm DAppNode Package for a production-ready setup via UI or CLI. Get started now.

- Repository: [Ethersphere/awesome-swarm](https://github.com/ethersphere/awesome-swarm)
- Tags: how-to-guide
- Published: 2026-03-01

---

**You can deploy a production-ready Swarm node on DAppNode by installing the official Swarm DAppNode Package from the rndlabs repository, which provides multi-architecture Docker images and automated configuration through the DAppNode UI or CLI.**

This guide walks through deploying and managing Swarm nodes on the DAppNode platform using the **ethersphere/awesome-swarm** repository as the authoritative index. While Awesome-Swarm serves as the curated gateway that lists the package at line 133 of [`README.md`](https://github.com/ethersphere/awesome-swarm/blob/main/README.md), the actual deployment artifacts reside in the external `rndlabs/dappnodepackage-swarm` repository.

## Swarm DAppNode Package Architecture

A DAppNode package is a self-contained bundle that abstracts Docker orchestration into a one-click installation. According to the Awesome-Swarm listing, the Swarm package supports **multi-platform deployments** (x86_64 and arm64) and bundles the Bee client—the official Swarm node implementation—into a production-ready container.

### Core Components

The Swarm DAppNode Package consists of four critical elements:

1. **Pre-built Docker Image** – The Bee client compiled for x86_64 or arm64 architectures (hosted at `rndlabs/bee`), eliminating manual compilation.
2. **[`docker-compose.yml`](https://github.com/ethersphere/awesome-swarm/blob/main/docker-compose.yml)** – Defines service parameters including persistent volumes (mounted at `/home/.../bee-data`), network ports, and environment variables such as `BEE_API_ADDR` and `BEE_BOOTNODES`.
3. **[`dappnode_package.json`](https://github.com/ethersphere/awesome-swarm/blob/main/dappnode_package.json)** – The DAppNode manifest describing package metadata, supported architectures, and UI configuration options that appear in the DAppNode store.
4. **Optional Web UI** – A lightweight interface (often React-based) exposing configuration fields for bootnodes, network selection, and resource limits without requiring file editing.

### Network Integration

When deployed, the package exposes the Bee HTTP API on port `1633`, enabling access to endpoints like `/bzz`, `/bytes`, `/feeds`, and `/health`. The node automatically registers its **ENR (Ethereum Node Record)** with the Swarm network, facilitating peer discovery and content routing without manual firewall configuration, as DAppNode handles TLS termination and secure networking.

## Deploying Swarm Nodes on DAppNode

### Installation via DAppNode UI

The standard workflow for deploying and managing Swarm nodes on the DAppNode platform uses the graphical interface:

```bash

# 1. Navigate to http://my-dappnode.local and open the DAppNode Store

# 2. Search for "Swarm" and select the "Swarm Mainnet" package

# 3. Click "Install" to trigger the following automated steps:

#    - Pulls the Docker image (e.g., rndlabs/bee:latest-amd64)

#    - Creates persistent storage at /home/.../bee-data

#    - Initializes the container with default environment variables

# 4. Verify the deployment:

curl http://my-dappnode.local:1633/health

# Expected output: {"status":"ok"}

# 5. Configure your applications to use:

export BZZ_URL=http://my-dappnode.local:1633

```

### CLI-Based Deployment

For headless servers or automated provisioning, use the DAppNode CLI:

```bash
dappnode package install swarm-mainnet

```

This command pulls the same Docker images and manifests referenced in the Awesome-Swarm catalog but executes without browser interaction, making it suitable for infrastructure-as-code workflows.

### Post-Installation Verification

After installation, confirm the node has joined the Swarm mainnet by checking its connectivity:

```bash
curl http://my-dappnode.local:1633/health

```

A response of `{"status":"ok"}` indicates the container is running. Check the DAppNode "Logs" tab or run `docker logs <container>` to view peer connection status and chunk synchronization progress.

## Managing Your Swarm Node on DAppNode

### Configuration Management

You can modify node behavior without SSH access by using the package UI at `http://my-dappnode.local/ui/swarm-mainnet`. Key adjustable parameters include:

- **Bootnodes**: Override default peers by setting `BEE_BOOTNODES` to a custom multi-address (e.g., `/dns4/bootnode.ethswarm.org/tcp/1633/p2p/12D3KooW...`).
- **Network Selection**: Switch between mainnet and testnet by changing the `BEE_NETWORK` environment variable to `testnet`.
- **Resource Allocation**: Adjust CPU/memory limits and storage paths through the UI fields mapped to Docker compose constraints.

### Upgrades and Maintenance

DAppNode automates image updates while preserving your node's state:

```bash

# Via CLI:

dappnode package update swarm-mainnet

# Or via UI: Click "Update" when a new version appears in the Dashboard

```

The upgrade process pulls newer Docker images from `rndlabs/bee` and restarts the container while maintaining the persistent volume at `/home/.../bee-data`, ensuring uploaded content and node identity remain intact.

### Data Backup Strategies

Because DAppNode uses standard Docker volumes, backup involves copying the persisted data directory:

```bash

# Create a backup of your node's state and uploaded files:

cp -r /home/.../bee-data /external-backup-location/

```

This safeguards your node's private keys, local chunk cache, and pinned content against hardware failure.

## Summary

- **Awesome-Swarm** (line 133 of [`README.md`](https://github.com/ethersphere/awesome-swarm/blob/main/README.md)) functions as the discovery portal, linking to the external `rndlabs/dappnodepackage-swarm` repository where the actual deployment logic resides.
- The package bundles Bee client Docker images for **x86_64 and arm64**, a [`docker-compose.yml`](https://github.com/ethersphere/awesome-swarm/blob/main/docker-compose.yml) for service definition, and a [`dappnode_package.json`](https://github.com/ethersphere/awesome-swarm/blob/main/dappnode_package.json) for DAppNode store integration.
- Deploy via the DAppNode Store UI or the `dappnode package install` CLI command, with automatic exposure of the Bee API on port `1633`.
- Manage configuration through environment variables like `BEE_BOOTNODES` and `BEE_NETWORK` without editing raw files.
- Upgrade through DAppNode's standard update mechanism while preserving data in persistent volumes.

## Frequently Asked Questions

### What is the relationship between Awesome-Swarm and the DAppNode package?

Awesome-Swarm is a curated catalog maintained by the Ethersphere organization that indexes Swarm ecosystem projects. According to [`CONTRIBUTING.md`](https://github.com/ethersphere/awesome-swarm/blob/main/CONTRIBUTING.md) (line 13), projects must be related to Bee or Swarm to be listed, excluding forks. The repository does not host the DAppNode package itself but provides a verified link to the `rndlabs/dappnodepackage-swarm` repository where the Docker images and deployment manifests are maintained.

### How do I switch my Swarm node between mainnet and testnet on DAppNode?

Access the Swarm package UI at `http://my-dappnode.local/ui/swarm-mainnet`, locate the `BEE_NETWORK` environment variable field, and change its value from `mainnet` to `testnet`. Save the configuration; DAppNode will restart the container with the new network parameter, causing the node to connect to testnet bootnodes and use the appropriate chain configuration.

### Can I run a Swarm node on ARM64 architecture using DAppNode?

Yes. The Awesome-Swarm listing explicitly notes that the Swarm DAppNode Package supports **multi-platform architectures**, including arm64 (ARM) and x86_64 (AMD64). DAppNode automatically pulls the appropriate image tag (e.g., `rndlabs/bee:latest-arm64`) based on your host hardware during installation.

### How do I troubleshoot a failing Swarm node on DAppNode?

First, check the node's health endpoint with `curl http://my-dappnode.local:1633/health`. If this fails or returns an error, open the DAppNode "Logs" tab for the Swarm package to view `docker logs` output in real-time. Common issues include insufficient disk space for the `/home/.../bee-data` volume or connectivity problems to the bootnodes specified in `BEE_BOOTNODES`. You can also pull the image manually for debugging: `docker pull rndlabs/bee:latest-amd64` and test with standalone `docker run` commands.