Requisitos previos Creación de contenedores de aplicaciones a partir de un espacio de trabajo de ROS Prueba de los contenedores

Ejecución de contenedores de aplicaciones

Para enviar un trabajo de simulación en AWS RoboMaker hay que seguir tres pasos: crear los contenedores de aplicaciones, vincular el contenedor a una aplicación de AWS RoboMaker y usar los contenedores para enviar un trabajo de simulación. En esta sección se explica cómo crear contenedores de aplicaciones con Docker para AWS RoboMaker. Usamos la aplicación de ejemplo “Hello World” para mostrar los pasos necesarios para crear contenedores de muestras de robots y aplicaciones de simulación para un ejemplo basado en ROS. En esta página también se muestra cómo probar el contenedor localmente.

Si no utiliza ROS, consulte la entrada del blog en que se describe cómo ejecutar cualquier simulación de alta fidelidad en AWS RoboMaker que sea compatible con GPU y contenedores.

Secciones

Requisitos previos
Creación de contenedores de aplicaciones a partir de un espacio de trabajo de ROS
Prueba de los contenedores

Requisitos previos

Antes de empezar, asegúrese de que su entorno de desarrollo tenga las dependencias necesarias. Docker, la AWS CLI y la herramienta de importación de VCS deben estar instalados en su equipo.

Instalación de la AWS CLI: https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html
Instalación de Docker: https://docs.docker.com/get-docker/
Instalación de la herramienta de importación de VCS (si es necesaria para su flujo de trabajo):


sudo pip3 install vcstool

También debe tener una cuenta de AWS con un rol de IAM que contenga los permisos siguientes:

Crear un rol de IAM
Cree recursos de AWS RoboMaker (trabajos de simulación, robots y aplicaciones de simulación)
Cree y cargue repositorios de Amazon ECR

Por último, debe conocer su número de cuenta y seleccionar una región en que ejecutar la simulación. AWS RoboMaker es compatible con las siguientes regiones de la lista Puntos de conexión y cuotas de AWS RoboMaker.

Creación de contenedores de aplicaciones a partir de un espacio de trabajo de ROS

Las simulaciones de AWS RoboMaker se componen de una aplicación de simulación y una aplicación de robot opcional. Cada una de estas aplicaciones se define mediante un nombre y una imagen de contenedor. En esta sección se muestra cómo crear la imagen del contenedor tanto para aplicaciones de simulación como para aplicaciones de robot. En el siguiente ejemplo, ambas aplicaciones se crean en un único espacio de trabajo. El enfoque que sigue se puede aplicar fácilmente a cualquier proyecto de ROS.

Para empezar, clone el repositorio de hello world e importe la fuente.


git clone https://github.com/aws-robotics/aws-robomaker-sample-application-helloworld.git helloworld 
cd helloworld
vcs import robot_ws < robot_ws/.rosinstall
vcs import simulation_ws < simulation_ws/.rosinstall

A continuación, cree un archivo que denominará Dockerfile en el directorio helloworld. Copie y pegue el contenido siguiente en:


# ======== ROS/Colcon Dockerfile ========
# This sample Dockerfile will build a Docker image for AWS RoboMaker 
# in any ROS workspace where all of the dependencies are managed by rosdep.
# 
# Adapt the file below to include your additional dependencies/configuration 
# outside of rosdep.
# =======================================

# ==== Arguments ====
# Override the below arguments to match your application configuration.
# ===================

# ROS Distribution (ex: melodic, foxy, etc.)
ARG ROS_DISTRO=melodic
# Application Name (ex: helloworld)
ARG APP_NAME=robomaker_app
# Path to workspace directory on the host (ex: ./robot_ws)
ARG LOCAL_WS_DIR=workspace
# User to create and use (default: robomaker)
ARG USERNAME=robomaker
# The gazebo version to use if applicable (ex: gazebo-9, gazebo-11)
ARG GAZEBO_VERSION=gazebo-9
# Where to store the built application in the runtime image.
ARG IMAGE_WS_DIR=/home/$USERNAME/workspace

# ======== ROS Build Stages ========
# ${ROS_DISTRO}-ros-base
#   -> ros-robomaker-base 
#      -> ros-robomaker-application-base
#         -> ros-robomaker-build-stage
#         -> ros-robomaker-app-runtime-image
# ==================================

# ==== ROS Base Image ============
# If running in production, you may choose to build the ROS base image 
# from the source instruction-set to prevent impact from upstream changes.
# ARG UBUNTU_DISTRO=focal
# FROM public.ecr.aws/lts/ubuntu:${UBUNTU_DISTRO} as ros-base
# Instruction for each ROS release maintained by OSRF can be found here: 
# https://github.com/osrf/docker_images
# ==================================

# ==== Build Stage with AWS RoboMaker Dependencies ====
# This stage creates the robomaker user and installs dependencies required 
# to run applications in RoboMaker.
# ==================================

FROM public.ecr.aws/docker/library/ros:${ROS_DISTRO}-ros-base AS ros-robomaker-base
ARG USERNAME
ARG IMAGE_WS_DIR

RUN apt-get clean
RUN apt-get update && apt-get install -y \
   lsb  \
   unzip \
   wget \
   curl \
   xterm \
   python3-colcon-common-extensions \
   devilspie \
   xfce4-terminal

RUN groupadd $USERNAME && \
   useradd -ms /bin/bash -g $USERNAME $USERNAME && \
   sh -c 'echo "$USERNAME ALL=(root) NOPASSWD:ALL" >> /etc/sudoers'
   
USER $USERNAME
WORKDIR /home/$USERNAME

RUN mkdir -p $IMAGE_WS_DIR

# ==== ROS Application Base ====
# This section installs exec dependencies for your ROS application.
# Note: Make sure you have defined 'exec' and 'build' dependencies correctly 
# in your package.xml files.
# ========================================
FROM ros-robomaker-base as ros-robomaker-application-base
ARG LOCAL_WS_DIR
ARG IMAGE_WS_DIR
ARG ROS_DISTRO
ARG USERNAME

WORKDIR $IMAGE_WS_DIR
COPY --chown=$USERNAME:$USERNAME $LOCAL_WS_DIR/src $IMAGE_WS_DIR/src

RUN sudo apt update && \ 
   rosdep update && \
   rosdep fix-permissions

# Note: This will install all dependencies. 
# You could further optimize this by only defining the exec dependencies. 
# Then, install the build dependencies in the build image.
RUN rosdep install --from-paths src --ignore-src -r -y

# ==== ROS Workspace Build Stage ==== 
# In this stage, we will install copy source files, install build dependencies
# and run a build. 
# ===================================
FROM ros-robomaker-application-base AS ros-robomaker-build-stage
LABEL build_step="${APP_NAME}Workspace_Build"
ARG APP_NAME
ARG LOCAL_WS_DIR
ARG IMAGE_WS_DIR

RUN  . /opt/ros/$ROS_DISTRO/setup.sh && \
   colcon build \
    --install-base $IMAGE_WS_DIR/$APP_NAME
    
# ==== ROS Robot Runtime Image ====
# In the final stage, we will copy the staged install directory to the runtime 
# image.
# =================================
FROM ros-robomaker-application-base AS ros-robomaker-app-runtime-image
ARG APP_NAME
ARG USERNAME
ARG GAZEBO_VERSION

ENV USERNAME=$USERNAME
ENV APP_NAME=$APP_NAME
ENV GAZEBO_VERSION=$GAZEBO_VERSION

RUN rm -rf $IMAGE_WS_DIR/src

COPY --from=ros-robomaker-build-stage $IMAGE_WS_DIR/$APP_NAME $IMAGE_WS_DIR/$APP_NAME

# Add the application source file to the entrypoint.
WORKDIR /
COPY entrypoint.sh /entrypoint.sh
RUN sudo chmod +x /entrypoint.sh && \
   sudo chown -R $USERNAME /entrypoint.sh && \
   sudo chown -R $USERNAME $IMAGE_WS_DIR/$APP_NAME
   
ENTRYPOINT ["/entrypoint.sh"]

El archivo Dockerfile que acaba de crear es un conjunto de instrucciones que se utiliza para crear imágenes Dockerfile. Lea los comentarios del Dockerfile para hacerse una idea de lo que se está creando y adáptelo según sus necesidades. Para facilitar el desarrollo, el Dockerfile se basa en las imágenes oficiales de Docker de ROS mantenidas por la Open Source Robotics Foundation (OSRF). Sin embargo, cuando se ejecute en producción, puede crear la imagen base de ROS con el conjunto de instrucciones de origen OSRF en GitHub para evitar el impacto de los cambios iniciales.

Cree un nuevo archivo denominado “entrypoint.sh“.


#!/bin/bash
set -e
source "/home/$USERNAME/workspace/$APP_NAME/setup.bash"
if [[ -f "/usr/share/$GAZEBO_VERSION/setup.sh" ]]
then
   source /usr/share/$GAZEBO_VERSION/setup.sh
fi
printenv
exec "${@:1}"

Un archivo ENTRYPOINT es un archivo ejecutable que se ejecuta cuando se genera el contenedor Docker. Utilizamos un punto de entrada como origen del espacio de trabajo de ROS, por lo que podemos ejecutar los comandos roslaunch en AWS RoboMaker fácilmente. Es posible que desee añadir sus propios pasos de configuración del entorno a este archivo ENTRYPOINT.

Nuestro Dockerfile utiliza una compilación de varias etapas y almacenamiento en caché integrado con Docker BuildKit. Las compilaciones de varias etapas permiten usar flujos de trabajo con pasos de compilación independientes, por lo que las dependencias de compilación y el código fuente no se copian en la imagen de tiempo de ejecución. Esto reduce el tamaño de la imagen de Docker y mejora el rendimiento. Al almacenar archivos creados anteriormente, las operaciones de almacenamiento en caché aceleran las compilaciones futuras.

Utilice este comando para compilar la aplicación:


DOCKER_BUILDKIT=1 docker build . \
 --build-arg ROS_DISTRO=melodic \
 --build-arg LOCAL_WS_DIR=./robot_ws \
 --build-arg APP_NAME=helloworld-robot-app \
 -t robomaker-helloworld-robot-app

Una vez creada la aplicación de robot, puede crear la aplicación de simulación de la siguiente manera:


DOCKER_BUILDKIT=1 docker build . \
 --build-arg GAZEBO_VERSION=gazebo-9 \
 --build-arg ROS_DISTRO=melodic \
 --build-arg LOCAL_WS_DIR=./simulation_ws \
 --build-arg APP_NAME=helloworld-sim-app \
 -t robomaker-helloworld-sim-app

Ejecute el comando docker images para confirmar que las imágenes de Docker se hayan creado correctamente. El resultado debe tener el siguiente aspecto:


Administrator:~/environment/helloworld (ros1) $ docker images
REPOSITORY                       TAG          IMAGE ID       CREATED          SIZE
robomaker-helloworld-sim-app     latest       5cb08816b6b3   6  minutes ago  2.8GB
robomaker-helloworld-robot-app   latest       b5f6f755feec   10 minutes ago  2.79GB

Si es así, significa que ha creado sus imágenes de Docker correctamente. Es aconsejable probarlas localmente antes de cargarlas para usarlas con AWS RoboMaker. En el paso siguiente se describe cómo hacerlo.

Prueba de los contenedores

Los comandos que se indican a continuación le permiten ejecutar la aplicación en su entorno de desarrollo local.

Inicio de la aplicación de robot:


docker run -it -v /tmp/.X11-unix/:/tmp/.X11-unix/ \
-u robomaker -e ROBOMAKER_GAZEBO_MASTER_URI=http://localhost:5555 \
-e ROBOMAKER_ROS_MASTER_URI=http://localhost:11311 \
robomaker-helloworld-robot-app:latest roslaunch hello_world_robot rotate.launch

Inicio de la aplicación de simulación:


docker run -it -v /tmp/.X11-unix/:/tmp/.X11-unix/ \
-u robomaker -e ROBOMAKER_GAZEBO_MASTER_URI=http://localhost:5555 \
-e ROBOMAKER_ROS_MASTER_URI=http://localhost:11311 \
robomaker-helloworld-sim-app:latest roslaunch hello_world_simulation empty_world.launch

Una vez que haya confirmado que los contenedores funcionan correctamente, podrá publicar los contenedores de la aplicación en Amazon ECR y, a continuación, enviar un trabajo de simulación.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Desarrollo

Publicación de contenedores de aplicaciones