🚀 Getting Started
Install the bridge on a ROS 2 robot and watch it come online in the console.
Prerequisites
The bridge ships as one package per ROS 2 distribution, each in its own apt suite. All three suites are served today.
| ROS 2 distribution | Ubuntu | Package | apt suite | Supported until |
|---|---|---|---|---|
| Humble Hawksbill | 22.04 jammy |
ros-humble-fleetless-bridge |
humble |
May 2027 |
| Jazzy Jalisco | 24.04 noble |
ros-jazzy-fleetless-bridge |
jazzy |
May 2029 |
| Lyrical Luth | 26.04 resolute |
ros-lyrical-fleetless-bridge |
lyrical |
May 2031 |
Each date is that distribution’s own end of life, from the ROS 2 release schedule. A suite stops receiving versions when its distribution does.
You also need:
curl,gnupgandca-certificateson the robot. Theros:<distro>images ship none of the three; the block below installs them.- A console account at https://console.fleetless.dev.
Fleetless is in closed beta. New organizations open in small rounds — leave your address on the waiting list and we will write when one does.
1. Create the robot
In the console, open Robots and create one. That mints a Fleetless token
(frt_…) binding one bridge process to exactly this robot. The token is shown
once and never read back, so copy it before you leave the page.
A lost token is replaced by rotating it on the robot’s Overview, which stops the robot until the new one reaches it.
2. Install the bridge
The packages are served signed from apt.fleetless.dev. Substitute your own
distribution for humble; the suite name and the package name change
together, and nothing else does.
export ROS_DISTRO=humble # or jazzy, or lyrical
sudo apt-get update
sudo apt-get install -y curl gnupg ca-certificates
curl -fsSL https://apt.fleetless.dev/key.gpg \
| sudo tee /usr/share/keyrings/fleetless.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/fleetless.gpg] https://apt.fleetless.dev $ROS_DISTRO main" \
| sudo tee /etc/apt/sources.list.d/fleetless.list
sudo apt-get update
sudo apt-get install -y "ros-$ROS_DISTRO-fleetless-bridge"
Each suite carries only its own distribution’s package. Mismatch the suite and
the package name and apt answers Unable to locate package, rather than
installing the wrong thing. The package is Architecture: all and serves
amd64 and arm64 from one build.
3. Start it
source /opt/ros/$ROS_DISTRO/setup.bash
source ~/your_ws/install/local_setup.bash # see the warning below
export FLEETLESS_TOKEN=frt_...
ros2 launch fleetless_bridge bridge.launch.py
Source your own workspace overlay, not just /opt/ros/$ROS_DISTRO. A
bridge started without it connects and reports itself healthy, then cannot
resolve your own message types and cannot find the package:// meshes your
URDF references. The console reports those meshes as missing from the
robot's workspace while they sit right there.
Environment variables
| Variable | Required | Default | Meaning |
|---|---|---|---|
FLEETLESS_TOKEN |
yes | — | The robot’s token, created once in the console. It binds this bridge to exactly one robot. |
FLEETLESS_CLOUD_URL |
no | wss://api.fleetless.dev/bridge |
The cloud endpoint. |
FLEETLESS_STATE_DIR |
no | ~/.local/state/fleetless-bridge |
Where the bridge keeps which goal belongs to which job, so a restarted bridge still recognises its running jobs. Never /tmp. If it cannot be written, jobs still run, but after a restart their goals show up as external ones. |
Set them in the launch file or in the environment. The launch file restarts the
process five seconds after it dies, so a crash loop backs off visibly in the
log instead of flooding it. Bandwidth shaping is a fleetless.yaml section
now: see low_bandwidth.
What you should see
The robot turns connected in the console within a few seconds. Started without a token, the bridge stops instead, with a sentence rather than a stack trace:
FLEETLESS_TOKEN is not set. Create the robot in the Fleetless console and
pass its token via the launch file or environment.
The cloud serves a window of bridge protocol versions. A version is deprecated by the cloud release that supersedes it and served for 90 more days. Inside the window an old bridge works and its robot page says retiring with the date.
After the date the bridge is refused at connect and retries every few minutes until it is upgraded.
Protocol 5's cutover on 2026-09-29 skipped that window. Protocols 2, 3 and 4 stopped being served at once, not after 90 days — a deliberate one-time cut while Fleetless is still building up, not the pattern future bumps will follow.
A bridge below 6.0.0 is refused at connect (hello_error,
bridge_too_old), naming the release to install. One speaking a newer
protocol than the cloud serves is refused with protocol_mismatch.
| Protocol | Bridge from | Status | Served until |
|---|---|---|---|
| 5 | 6.0.0 | current | — |
Latest bridge package: 6.1.0.
Your organisation’s Fleetless users get a mail when a version is deprecated, two weeks before it stops, when a robot is refused for it, and when a newer bridge package is published. Upgrading is an ordinary apt upgrade:
sudo apt-get update
sudo apt-get install --only-upgrade "ros-$ROS_DISTRO-fleetless-bridge"
Exit codes
A supervisor cannot read log messages, so the exit code says what happened.
| Code | Meaning |
|---|---|
0 |
Stopped on request (SIGINT/SIGTERM). Nothing is wrong. |
1 |
Stopped by an unexpected error. |
2 |
Stopped because retrying in this process cannot help: no token, an unusable cloud URL, a token the cloud rejects, a protocol version the cloud refuses, or another bridge that took the robot over. |
Code 2 is deliberate. A bridge that kept retrying a rejected token would
hammer the cloud and hide the real problem, and one that reconnected after
being superseded would trade the robot back and forth with its replacement
forever. Everything else is retried with a jittered exponential backoff from
1 s up to 30 s.
A protocol version the cloud refuses waits one to two minutes before that exit, so the launch file’s respawn retries every couple of minutes and a fresh process picks up an upgraded package by itself.
Next
- Exposing a Robot — the document that decides which topics, services, actions and cameras the robot’s API carries.
- Create an App — the client your users sign into, and the robots it is allowed to reach.
- The App Starter — a working dashboard on
@fleetless/sdk, ready to clone.