[Feature Request] Official Docker images

[hden]

Give there are so many build / installation related issues. Why not just provide a base image and a minimal official image for each of the official wrappers?

Benefits:

• Reproducible environment / builds / installation
• Quick access to development environment
• Less complaints on GitHub

A user can always capture image in the container and/or forward X11 if necessary.

[rambo]

I've been spending today getting something that compiles on Alpine also on aarch64:

#############################
# Base stage for all builds #
#############################
FROM alpine:3.11 as build_env

# Very basic compiler deps
RUN apk --no-cache add \
    curl \
    gzip \
    tar \
    build-base \
    cmake \
    llvm \
    clang \
    && true


##################
# Build apriltag #
##################
FROM build_env as apriltag_build
ENV AP_VERSION=3.1.1

WORKDIR /usr/src
RUN curl https://codeload.github.com/AprilRobotics/apriltag/tar.gz/$AP_VERSION -o apriltag.tar.gz \
    && tar -xzf apriltag.tar.gz \
    && cd /usr/src/apriltag-$AP_VERSION \
    && mkdir build && cd build \
    && cmake -DCMAKE_INSTALL_PREFIX=/opt/apriltag/$AP_VERSION -DCMAKE_BUILD_TYPE=Release ../ \
    && make -j4 all install \
    && cd /opt/apriltag/ && ln -s $AP_VERSION /opt/apriltag/current \
    && true


####################
# Minimal apriltag #
####################
FROM alpine:3.11 as apriltag
COPY --from=apriltag_build /opt/apriltag /opt/apriltag
# Add the libraries to "ldconfig"
RUN echo "/lib:/usr/local/lib:/usr/lib" >>/etc/ld-musl-$(uname -m).path \
    && echo "/opt/apriltag/current/lib64" >>/etc/ld-musl-$(uname -m).path \
    && true


######################
# Build librealsense #
######################
FROM build_env as librealsense_build

ENV RS_VERSION=2.34.0

COPY --from=apriltag /opt/apriltag /opt/apriltag

# Download and unpack (ordered like this so we can cache this phase when adjusting build settings / deps)
WORKDIR /usr/src
RUN curl https://codeload.github.com/IntelRealSense/librealsense/tar.gz/v$RS_VERSION -o librealsense.tar.gz \
    && tar -xzf librealsense.tar.gz \
    && true

# build deps
RUN apk --no-cache add \
    libpthread-stubs \
    linux-headers \
    musl-dev \
    libffi-dev \
    libbsd-dev \
    openssl-dev \
    libusb-dev \
    libx11-dev \
    libxrandr-dev \
    libxinerama-dev \
    glfw-dev \
    glm-dev \
    glew-dev \
    libxcb-dev \
    libxi-dev \
    fts-dev \
    libc-dev \
    hidapi-dev \
    vulkan-loader-dev \
    eudev-dev \
    && true

# Compile
# either alpine or librealsense is being weird with limits.h so MAX_INPUT is defined manually
# We also need to add a missing include to endian.h and sys/select.h
# and do a bit of other patching (like machine string, threads to main CMakeLists because aarch64 fails otherwise)
RUN cd /usr/src/librealsense-$RS_VERSION \
    && grep -q '#include <endian.h>' src/tm2/tm-device.cpp || sed -i '1s/^/#include <endian.h>\n/' src/tm2/tm-device.cpp \
    && grep -q '#include <sys/select.h>' tools/terminal/auto-complete.cpp || sed -i '1s/^/#include <sys\/select.h>\n/' tools/terminal/auto-complete.cpp \
    && sed -i 's/project(librealsense2 LANGUAGES CXX C)/project(librealsense2 LANGUAGES CXX C)\nfind_package(Threads REQUIRED)/' CMakeLists.txt \
    && sed -i 's/aarch64-linux-gnu/aarch64-alpine-linux-musl/' CMake/unix_config.cmake \
    && test $(uname -m) == "aarch64" && export MACHINE=aarch64-linux-gnu || true \
    && mkdir build && cd build \
    && cmake -DCMAKE_C_FLAGS="-D_BSD_SOURCE -D_GNU_SOURCE -Wno-pedantic -DMAX_INPUT=255" \
             -DCMAKE_CXX_FLAGS="-D_BSD_SOURCE -D_GNU_SOURCE -Wno-pedantic -DMAX_INPUT=255" \
             -DCMAKE_PREFIX_PATH=/opt/apriltag/current/ \
             -DCMAKE_INSTALL_PREFIX=/opt/librealsense/$RS_VERSION \
             -DBUILD_GRAPHICAL_EXAMPLES=OFF \
             -DFORCE_RSUSB_BACKEND=ON \
             -DCMAKE_BUILD_TYPE=Release ../ \
    && make -j4 all install \
    && cd /opt/librealsense/ && ln -s $RS_VERSION /opt/librealsense/current \
    && echo "/lib:/usr/local/lib:/usr/lib" >>/etc/ld-musl-$(uname -m).path \
    && echo "/opt/apriltag/current/lib64" >>/etc/ld-musl-$(uname -m).path \
    && echo "/opt/librealsense/current/lib64" >>/etc/ld-musl-$(uname -m).path \
    && true

########################
# Minimal librealsense #
########################
FROM alpine:3.11 as librealsense

# Runtime deps
RUN apk --no-cache add \
    libusb \
    udev \
    libstdc++ \
    && true

COPY --from=apriltag /opt/apriltag /opt/apriltag
COPY --from=librealsense_build /opt/librealsense /opt/librealsense

# Add the libraries to "ldconfig"
RUN echo "/lib:/usr/local/lib:/usr/lib" >>/etc/ld-musl-$(uname -m).path \
    && echo "/opt/apriltag/current/lib64" >>/etc/ld-musl-$(uname -m).path \
    && echo "/opt/librealsense/current/lib64" >>/etc/ld-musl-$(uname -m).path \
    && true
WORKDIR /opt/librealsense/current/

docker build --target librealsense  -t librealsense:2.34.0 .
sudo docker run --privileged -it --rm librealsense:2.34.0 /opt/librealsense/current/bin/rs-enumerate-devices

Haven't figured out yet what are the correct host udev settings to allow non-root user to control devices (the build box is a Jetson Nano, I can't run the official ubuntu realsense tools as user either).

The librealsense target is nice and small at 370MB with 340MB being the actual compiled realsense installation. The build stage is 2.17GB (hurk...)

edit: rs-enumerate-devices output https://gist.github.com/rambo/8f9684ba6eac5da796a97e251e1db8e1

[rambo]

Ok, I bit the bullet and figured out how to do multi-arch tags.

Docker hub (for everyone to use until we have official images) https://hub.docker.com/r/advian/librealsense
The source repo https://github.com/advian-oss/librealsense-docker, uses buildx so adding new archs is relatively simple (testing them might not be though, I can only test on amd64 and aarch64).

And a minimal example application to test this end-to-end https://github.com/advian-oss/librealsense-docker/tree/master/example

Edit: forgot to mention that this image strips debug symbols and is 85MB in size without them.

Edit2: new urls, uses buildx now.

[tomatac]

I anybody developing successfully within a docker container (Ubuntu 20.04 or 18.04, camera only; not ROS)?
I am looking for a solution that would work on a PC (Intel based) and deploy on a Nvidia Jetson.

[rambo]

Ubuntu is trivial, there's official librealsense packages so just add the repo and install via apt inside your Dockerfile before building your sw inside docker. To deploy on Jetson you need either build aarch64 images on the Jetson or use buildx to cross-build them under qemu (this is sloooooow but plays nicer with CI where it might not be that easy to get aarch64 runners unless you have spare hw to act as such)

[rambo]

Here's an example that works both on amd64 and aarch64 (the actual software is written in Rust and proprietary so I can't show you that):

Build with docker build --target production -t myrealsensething:latest . you need to run the container in privileged mode for it to have low level usb access (or start fiddling with the advanced permissions stuff to give it only access to the realsense devices)

######################
# Base builder image #
######################
FROM ubuntu:18.04 as builder_base
# Basic deps and rustup

RUN apt-get update && apt-get install -y \
    curl \
    gzip \
    tar \
    build-essential \
    pkg-config \
    cmake \
    llvm \
    clang \
    bash \
    software-properties-common \
    && curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs -o /tmp/rustup-init.sh \
    && chmod a+x /tmp/rustup-init.sh \
    && /tmp/rustup-init.sh -y \
    && true


####################
# Main build image #
####################
FROM builder_base as builder
ARG RS_PKG_VERSION=2.35\*
SHELL ["/bin/bash", "-c"]

WORKDIR /usr/src/depthservice

RUN apt-key adv --keyserver keys.gnupg.net --recv-key F6E65AC044F831AC80A06380C8B3A55A6F3EFCDE || apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-key F6E65AC044F831AC80A06380C8B3A55A6F3EFCDE \
    && add-apt-repository "deb http://realsense-hw-public.s3.amazonaws.com/Debian/apt-repo bionic main" -y \
    && apt-get update && apt-get install -y \
    libzmq5 \
    libzmq3-dev \
    librealsense2=$RS_PKG_VERSION \
    librealsense2-dev=$RS_PKG_VERSION \
    librealsense2-dbg=$RS_PKG_VERSION \
    && rm -rf /var/lib/apt/lists/* && apt-get clean \
    && true

ENV RUST_BACKTRACE=1
# Build dummy main with the project's Cargo lock and toml
# This is a docker trick in order to avoid downloading and building
# dependencies when lock and toml not is modified.
COPY Cargo.lock .
COPY Cargo.toml .
RUN mkdir src \
    && echo "fn main() {print!(\"Dummy main\");} // dummy file" > src/main.rs \
    && source $HOME/.cargo/env \
    && cargo build --release \
    && rm target/release/deps/depthservice* \
    && true

# Build the actual project
COPY src ./src
RUN  source $HOME/.cargo/env \
     && cargo build --release \
     && true


####################
# Production image #
####################
FROM ubuntu:18.04 as production
ARG RS_PKG_VERSION=2.35\*
SHELL ["/bin/bash", "-c"]

RUN apt-get update && apt-get install -y \
    software-properties-common \
    && true

RUN apt-key adv --keyserver keys.gnupg.net --recv-key F6E65AC044F831AC80A06380C8B3A55A6F3EFCDE || apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-key F6E65AC044F831AC80A06380C8B3A55A6F3EFCDE \
    && add-apt-repository "deb http://realsense-hw-public.s3.amazonaws.com/Debian/apt-repo bionic main" -y \
    && apt-get update && apt-get install -y \
    libzmq5 \
    librealsense2=$RS_PKG_VERSION \
    && rm -rf /var/lib/apt/lists/* && apt-get clean \
    && true

ENV RUST_BACKTRACE=1
COPY --from=builder /usr/src/depthservice/target/release/depthservice /usr/local/bin
ENTRYPOINT [ "bash", "-c" ]
CMD ["/usr/local/bin/depthservice"]


#########
# Tests #
#########
FROM builder as test
RUN  source $HOME/.cargo/env \
     && cargo test \
     && echo "source $HOME/.cargo/env" >>$HOME/.bashrc \
     && true

ENTRYPOINT [ "bash", "-lc" ]
CMD ["cargo test"]

I anybody developing successfully within a docker container (Ubuntu 20.04 or 18.04, camera only; not ROS)?
I am looking for a solution that would work on a PC (Intel based) and deploy on a Nvidia Jetson.

Hello,
We are working on official docker image support for librealsense.
if you'd like to try an unofficial version in the meantime you can try this image:

Realsense DockerHub Image

• Ubuntu 20.04
• Librealsense including non-graphical samples, python bindings and network support
• Release build W/O debug symbols
• Multi-target manifest supporting x86_64 and ARM64v8 (we can add ARM32v7 if needed)

To run in non-privileged mode, from shell:

docker run -it --rm \
    -v /dev:/dev \
    --device-cgroup-rule "c 81:* rmw" \
    --device-cgroup-rule "c 189:* rmw" \
    danielpiro/realsense

you can then test the device with: rs-depth

• Note - The linux kernel in the base system supports librealsense (might need to be patched if you have older kernel )

[tomatac]

Hi @daniel-piro, Thank you!
Is there Dockerfile that I can edit and contribute to if there is room for improvements?

@tomatac the source Docker files will be included in the librealsense repository soon.
Feedback from the community is welcome!

[tomatac]

Hi @daniel-piro, Do you know if that means few days or few weeks. I am working at a project right now and I am trying to see if Docker is a feasible option. Thank you!