Running Home Assistant on NVIDIA Jetson Orin Nano: A Complete Docker Setup Guide

Running Home Assistant on a Jetson Orin Nano: My Docker Setup

My Home Assistant doesn’t run on a Raspberry Pi or a mini PC. It runs in a Docker container on an NVIDIA Jetson Orin Nano, the same box that runs the rest of my homelab: 24 containers on 8 GB of RAM. It has been the hub for my Zigbee sensors, Z-Wave devices, Ring cameras and a few cloud integrations for long enough that I know where the sharp edges are.

This is how it’s set up, what the Jetson is good and bad at for this job, and the things that have actually broken.

Why a Jetson and not a Pi

Honestly, Home Assistant alone does not need a Jetson. A Pi 5 or any small x86 box runs it fine. I put it on the Orin Nano because the Jetson was already the always-on server for everything else: password manager, DNS, monitoring, a local LLM through Ollama, and a custom app that reads sensor data from Home Assistant. Keeping Home Assistant on the same host means that app talks to it over localhost, and there’s one machine to back up and patch instead of two.

The trade-offs are real, though:

  • It’s ARM64. The official Home Assistant image supports it, so that part is a non-issue. A few third-party containers are x86-only, so check before you plan around one.
  • 8 GB is shared with the GPU. The Orin Nano has unified memory, so the CPU, the GPU and every container draw from the same 8 GB. That turns out to be the real constraint (more below).
  • No Home Assistant OS. On a Jetson you run the container install, which means no add-ons. Everything an add-on would do runs as its own container instead.

The layout

Home Assistant is one container, and the “add-ons” are their own containers next to it:

  • homeassistant: the official ghcr.io/home-assistant/home-assistant:stable image, on the host network.
  • Zigbee: handled inside Home Assistant by ZHA, using a Sonoff Zigbee 3.0 USB dongle passed through as /dev/ttyUSB0. It drives Aqara temperature and humidity sensors.
  • Z-Wave: a separate Z-Wave JS UI container owns the Zooz Z-Wave stick on /dev/ttyACM0. Home Assistant connects to it through the Z-Wave JS integration over its websocket.
  • Ring: ring-mqtt bridges the Ring doorbell and cameras into a Mosquitto MQTT broker, and Home Assistant picks them up through MQTT discovery.
  • Cloud integrations: Hatch and an Owlet sock run as custom components inside Home Assistant.

Splitting Z-Wave into its own container was the best decision here. I can restart or update Home Assistant without the Z-Wave network re-interviewing anything, and Z-Wave JS UI gives a much better view of the mesh than the built-in panel.

The compose file

services:
  homeassistant:
    container_name: homeassistant
    image: ghcr.io/home-assistant/home-assistant:stable
    network_mode: host
    privileged: true
    restart: unless-stopped
    environment:
      - TZ=America/Los_Angeles
    volumes:
      - /home/onehub/homeassistant:/config
      - /etc/localtime:/etc/localtime:ro
      - /run/dbus:/run/dbus:ro
      - /dev:/dev

A few notes on the choices:

  • network_mode: host is worth it. mDNS and SSDP discovery, HomeKit and a lot of local integrations either need it or behave much better with it. You lose container port isolation, so Home Assistant just listens on 8123 on the host.
  • Mounting /dev with privileged is the blunt option. The tidier alternative is to pass only the devices you need (devices: - /dev/ttyUSB0:/dev/ttyUSB0). The catch is that USB device names can change after a reboot or replug. If you go the explicit route, use the stable /dev/serial/by-id/... path instead of ttyUSB0.
  • /run/dbus is there for Bluetooth. Drop it if you don’t use Bluetooth.

The real constraint: memory

CPU has never been the problem on the Orin Nano. Memory is. With unified memory, every container plus the GPU shares 8 GB, and once a few heavier services are running it fills up quickly. Two things made the difference:

  1. Disable the desktop. JetPack ships with GNOME, and on a headless server it’s pure waste. Disabling the display manager freed roughly 5 GB:
    sudo systemctl disable gdm --now
    # to bring it back: sudo systemctl enable gdm --now
  2. Put memory limits on the hungry containers. A few of my heavier services have an explicit mem_limit in compose, so one leaky container gets killed and restarted instead of pushing the whole box into swap.

If you also run Ollama on the same Jetson, remember that model memory comes out of the same 8 GB. Small models only, and expect Home Assistant to feel it if a big model is loaded.

Remote access without opening ports

Nothing on my router is port-forwarded. Remote access goes through a Cloudflare Tunnel with Cloudflare Access in front of it, so you hit an identity check before Home Assistant’s own login.

At home, I didn’t want LAN traffic hair-pinning out to Cloudflare and back. So the local DNS (AdGuard Home) rewrites the same hostname to the Jetson’s LAN address, and a reverse proxy there serves it with a real certificate. Same URL at home and away, and the phone app never needs a second server address.

One gotcha if you put a reverse proxy in front of Home Assistant: it rejects proxied requests until you tell it to trust the proxy. In configuration.yaml:

http:
  use_x_forwarded_for: true
  trusted_proxies:
    - 127.0.0.1
    - 172.16.0.0/12   # Docker networks, if the proxy runs in a container

What has actually broken

  • Custom components after updates. The Owlet integration is a custom component that I had to patch to work, and a Home Assistant update can undo that or break it outright. If you rely on a patched custom component, keep the patch somewhere outside /config/custom_components so you can re-apply it, and read the release notes before updating.
  • Automatic updates. Following on from that, Watchtower auto-updates my containers daily. That’s fine for most of them, but Home Assistant is the one container where an unattended update can quietly break an integration. Excluding it with the label com.centurylinklabs.watchtower.enable=false and updating it by hand is the safer setup.
  • USB device names. See the /dev/serial/by-id note above.

Backups

Everything Home Assistant needs lives in the /config bind mount, so backing it up is a matter of copying that folder (with the container stopped, or at least after a fresh home-assistant_v2.db checkpoint). A nightly script copies it locally with a 14-day rotation. The weak point, which I’m calling out because it’s true for a lot of homelabs: those backups sit on the same NVMe drive as the live data. An offsite copy is next on my list.

Would I do it this way again?

If the Jetson is already your always-on server, yes. Home Assistant runs happily in a corner of it, the container install is easy to rebuild, and keeping the Zigbee, Z-Wave and MQTT pieces in separate containers makes each one easy to update and debug on its own.

If you’re buying hardware just for Home Assistant, don’t buy a Jetson for it. Get a Pi 5 or a used mini PC and run Home Assistant OS, which gives you add-ons and one-click backups. The Jetson makes sense when you want local AI on the same box. For comparing the two boards, see Jetson Orin Nano vs Raspberry Pi 5, and for everything else running on this server, the OneHub tour.

Enjoying this post?

Get more guides like this delivered straight to your inbox. No spam, just tech and trails.