Criar de contêineres de aplicativos - AWS RoboMaker
Pré-requisitosCriação de contêineres de aplicativos a partir de um espaço de trabalho ROSTestando seus contêineres

Aviso de fim do suporte: em 10 de setembro de 2025, AWS interromperá o suporte para AWS RoboMaker. Depois de 10 de setembro de 2025, você não poderá mais acessar o AWS RoboMaker console ou AWS RoboMaker os recursos. Para obter mais informações sobre como fazer a transição para ajudar AWS Batch a executar simulações em contêineres, visite esta postagem no blog.

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Criar de contêineres de aplicativos

Há três etapas para enviar um trabalho de simulação no AWS RoboMaker: criar os contêineres do aplicativo, vincular o contêiner a um aplicativo AWS RoboMaker e usar os contêineres para enviar um trabalho de simulação. Esta seção aborda como criar contêineres de aplicativos usando o Docker do AWS RoboMaker. Usamos o aplicativo de exemplo “hello-world” para demonstrar as etapas necessárias para criar contêineres de robôs de amostra e aplicativos de simulação de um exemplo baseado em ROS. Esta página também demonstra como testar seu contêiner localmente.

Se você não estiver usando ROS, consulte a postagem do blog que descreve como executar qualquer simulação de alta fidelidade no AWS RoboMaker com suporte a GPU e contêiner.

Pré-requisitos

Antes de começar, verifique se o seu ambiente de desenvolvimento tem as dependências necessárias. Você deve ter o Docker, o AWS CLI e o VCS Import Tool instalados em sua máquina. 

sudo pip3 install vcstool

Você também deve ter uma conta da AWS com um perfil do IAM contendo as seguintes permissões:

  • Criar uma função do IAM

  • Crie recursos do AWS RoboMaker (tarefas de simulação, robôs e aplicativos de simulação)

  • Crie e faça o upload de repositórios do Amazon ECR

Por fim, você precisa saber o número da sua conta e selecionar uma região na qual executará a simulação. O AWS RoboMaker é suportado nas seguintes regiões listadas Terminais e cotas do AWS RoboMaker

Criação de contêineres de aplicativos a partir de um espaço de trabalho ROS

As simulações do AWS RoboMaker são compostas por um aplicativo de simulação e um aplicativo opcional de robô. Cada um desses aplicativos é definido por um nome e uma imagem de contêiner. Esta seção demonstra como criar a imagem do contêiner para um aplicativo de simulação e um aplicativo de robô. No exemplo a seguir, os dois aplicativos são criados em um único espaço de trabalho. A abordagem a seguir é facilmente generalizável para qualquer projeto de ROS.

Para começar, clone o repositório hello world e importe a fonte. 

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

Depois, crie um novo arquivo de texto no diretório helloworld e atribua a ele o nome Dockerfile. Copie e cole o conteúdo a seguir: 

# ======== 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"]

O Dockerfile que você acabou de criar é um conjunto de instruções usado para criar imagens de Docker. Leia os comentários no Dockerfile para ter uma ideia do que está sendo construído e adapte conforme necessário às suas necessidades. Para facilitar o desenvolvimento, o Dockerfile é baseado nas imagens oficiais do ROS Docker mantidas pela Open Source Robotics Foundation (OSRF). No entanto, ao executar em produção, você pode optar por criar a imagem base do ROS com o conjunto de instruções de origem do OSRF no GitHub para evitar o impacto das alterações anteriores.

Em seguida, crie um novo arquivo chamado 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}"

Um arquivo ENTRYPOINT é um executável que é executado quando o contêiner Docker é gerado. Estamos usando um ponto de entrada para fornecer o espaço de trabalho do ROS, para que possamos executar comandos roslaunch com facilidade no AWS RoboMaker. Talvez você queira adicionar suas próprias etapas de configuração do ambiente a esse arquivo ENTRYPOINT.

O nosso Dockerfile usa uma compilação em várias etapas e um armazenamento em cache integrado com o Docker BuildKit. As compilações de vários estágios permitem fluxos de trabalho com etapas de compilação separadas, para que as dependências de construção e o código-fonte não sejam copiados na imagem do runtime. Isso reduz o tamanho da imagem do Docker e melhora o desempenho. As operações de cache aceleram futuras compilações armazenando arquivos criados anteriormente.

Construa o aplicativo de robô com o seguinte comando: 

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

Depois que o aplicativo do robô for construído, você poderá criar o aplicativo de simulação da seguinte forma: 

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

Execute o comando docker images para confirmar que as imagens do Docker foram criadas com sucesso. A saída deve ser semelhante à seguinte: 

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

Neste ponto, você construiu com sucesso suas imagens do Docker. É uma boa ideia testá-los localmente antes de enviá-los para uso com o AWS RoboMaker. A próxima seção mostra como fazer isso.

Testando seus contêineres

Os comandos a seguir permitem que você execute o aplicativo em seu ambiente de desenvolvimento local.

Inicie o aplicativo de robô:

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

Inicie o aplicativo de simulação: 

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

Depois de confirmar que seus contêineres estão funcionando corretamente, você pode publicar contêineres de aplicativos no Amazon ECR e, em seguida, Enviar um trabalho de simulação.