Skip to content

Docker Setup#

Docker provides a containerized environment for running AutoSDV without modifying your host system. This is ideal for development, testing, and simulation scenarios.

Use Cases#

Docker is recommended for: - Development and Testing: Consistent environment across different machines - Simulation: Running AutoSDV without physical hardware - CI/CD: Automated testing and deployment - Quick Evaluation: Try AutoSDV without full installation

Prerequisites#

Host System Requirements#

  • Ubuntu 20.04 or 22.04 (other Linux distributions may work)
  • NVIDIA GPU with driver 470+ (for GPU acceleration)
  • At least 50GB free disk space
  • 16GB+ RAM recommended

Software Requirements#

  1. Docker Engine (20.10 or newer): 

    # Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Add user to docker group
sudo usermod -aG docker $USER
# Log out and back in for group changes to take effect

  2. NVIDIA Container Toolkit (for GPU support): 

    # Add NVIDIA repository
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-docker.list

# Install nvidia-container-toolkit
sudo apt update
sudo apt install nvidia-container-toolkit
sudo systemctl restart docker

  3. Docker Compose (optional, for multi-container setups): 

    sudo apt install docker-compose

Quick Start#

Step 1: Clone AutoSDV Repository#

git clone -b 2025.02 --recursive https://github.com/NEWSLabNTU/AutoSDV.git
cd AutoSDV/docker

Step 2: Bootstrap Docker Environment#

Set up cross-architecture support (required for ARM64 emulation on x86_64):

make bootstrap

Step 3: Build Docker Image#

Build the AutoSDV Docker image:

make build

This creates an image with: - Ubuntu 22.04 base with ROS 2 Humble - Autoware 2025.02 pre-installed - All AutoSDV dependencies - CUDA and TensorRT support - Sensor driver libraries (except proprietary ones)

Step 4: Run Container#

Start an interactive container session:

make run

You'll enter a shell with AutoSDV ready to use at /home/developer/AutoSDV.

Docker Image Details#

Image Architecture#

The AutoSDV Docker image is built for ARM64 architecture to match the Jetson platform. On x86_64 hosts, QEMU provides transparent emulation.

Pre-installed Software#

  • ROS 2 Humble with desktop tools
  • Autoware 2025.02 binary release
  • CUDA 12.3 and TensorRT 8.6
  • Cyclone DDS configured as default
  • Development tools: git, vim, tmux, htop

Volume Mounts#

The make run command automatically mounts: - /tmp/.X11-unix for GUI applications - NVIDIA GPU devices for CUDA access

Advanced Usage#

Custom Run Options#

Run with additional volumes or ports:

docker run -it --rm \
  --gpus all \
  --network host \
  -v /path/to/data:/data \
  -v /dev:/dev \
  --privileged \
  autosdv:latest

Development Workflow#

For active development, mount your local code:

docker run -it --rm \
  --gpus all \
  -v $(pwd):/workspace/AutoSDV \
  -w /workspace/AutoSDV \
  autosdv:latest

GUI Applications#

Enable X11 forwarding for visualization tools:

xhost +local:docker
docker run -it --rm \
  --gpus all \
  -e DISPLAY=$DISPLAY \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  autosdv:latest

Then run GUI applications like RViz: 

# Inside container
rviz2

Multi-Container Setup#

Create a docker-compose.yml for complex deployments:

version: '3.8'

services:
  autosdv:
    image: autosdv:latest
    runtime: nvidia
    network_mode: host
    privileged: true
    volumes:
      - /dev:/dev
      - ./data:/data
    environment:
      - ROS_DOMAIN_ID=0
      - DISPLAY=${DISPLAY}
    command: ros2 launch autosdv_launch autosdv.launch.yaml

  monitoring:
    image: autosdv:latest
    runtime: nvidia
    network_mode: host
    environment:
      - ROS_DOMAIN_ID=0
    command: python3 /home/developer/AutoSDV/src/launcher/autosdv_launch/autosdv_launch/autosdv_monitor.py

Run with: 

docker-compose up

Container Management#

Save and Load Images#

Export image for deployment:

make save  # Creates autosdv_docker.tar.gz

Load on another machine:

docker load < autosdv_docker.tar.gz

Clean Up#

Remove container and image:

make clean

Limitations#

Hardware Access#

Docker containers have limited hardware access: - No direct LiDAR access (USB/Ethernet sensors need special configuration) - No CAN bus without --privileged flag - Camera access requires device mounting

Performance#

  • ARM64 emulation on x86_64 reduces performance
  • GPU passthrough adds overhead
  • Network performance may vary with Docker networking modes

Sensor Drivers#

The Docker image includes most drivers via rosdep, but:

  • ZED SDK: Cannot be fully used in Docker due to hardware requirements. Physical deployment requires native installation.
  • Blickfeld: Installed via rosdep in container
  • Velodyne: Installed via rosdep in container

For full ZED camera support, use native installation with ZED SDK Installation Guide.

Troubleshooting#

GPU Not Accessible#

Verify NVIDIA runtime: 

docker run --rm --gpus all nvidia/cuda:11.8.0-base-ubuntu22.04 nvidia-smi

Network Issues#

Use host networking for ROS 2 communication: 

docker run --network host ...

Permission Denied#

For device access, run with privileges: 

docker run --privileged -v /dev:/dev ...

Build Failures#

Clear Docker cache and rebuild: 

docker system prune -a
make bootstrap
make build

Integration with CI/CD#

GitHub Actions Example#

name: AutoSDV Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      - name: Set up Docker
        uses: docker/setup-buildx-action@v1

      - name: Build Docker image
        run: |
          cd docker
          make build

      - name: Run tests
        run: |
          docker run --rm autosdv:latest \
            bash -c "cd /home/developer/AutoSDV && colcon test"

Jenkins Pipeline Example#

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                sh 'cd docker && make build'
            }
        }

        stage('Test') {
            steps {
                sh 'docker run --rm autosdv:latest make test'
            }
        }
    }
}

Next Steps#