Realizzare container di applicazioni

Esistono tre passaggi per inviare un lavoro di simulazioneAWS RoboMaker: creare i contenitori dell'applicazione, collegare il contenitore a un'AWS RoboMakerapplicazione e utilizzare i contenitori per inviare un lavoro di simulazione. Questa sezione descrive come creare container di applicazioni utilizzando Docker forAWS RoboMaker. Utilizziamo l'applicazione hello-world per dimostrare i passaggi necessari per creare robot di esempio e contenitori per applicazioni di simulazione per un esempio basato su ROS. Questa pagina mostra anche come testare il contenitore localmente.

Se non utilizzi ROS, consulta il post del blog che descrive come eseguire qualsiasi simulazione ad alta fedeltàAWS RoboMaker con supporto per GPU e container.

Prerequisiti

Prima di iniziare, assicurati che il tuo ambiente di sviluppo abbia le dipendenze necessarie. È necessario che DockerAWS CLI, il e lo strumento di importazione VCS siano installati sul computer.

• Installare ilAWS CLI: https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install .html

• Installa Docker: https://docs.docker.com/get-docker/

• Installa lo strumento di importazione VCS (se necessario per il tuo flusso di lavoro):

sudo pip3 install vcstool

È inoltre necessario disporre di unAWS account con un ruolo IAM contenente le seguenti autorizzazioni:

• Creare un ruolo IAM.

• CreaAWS RoboMaker risorse (processi di simulazione, robot e applicazioni di simulazione)

• Creare e caricare Repository Amazon ECR

Infine, devi conoscere il tuo numero di conto e selezionare una regione in cui eseguire la simulazione. AWS RoboMakerè supportato nelle seguenti regioni elencateAWS RoboMaker endpoint e quote

Creazione di contenitori di applicazioni da uno spazio di lavoro ROS

AWS RoboMakerle simulazioni comprendono un'applicazione di simulazione e un'applicazione robotica opzionale. Ciascuna di queste applicazioni è definita da un nome e da un'immagine contenitore. Questa sezione dimostra come creare l'immagine del contenitore sia per un'applicazione di simulazione che per un'applicazione robotica. Nell'esempio seguente, entrambe le applicazioni sono compilare all'interno di un unico spazio di lavoro. L'approccio che segue è facilmente generalizzabile a qualsiasi progetto ROS.

Per iniziare, clonate ilhello world repository e importate il codice sorgente.

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

Quindi, crea un nuovo file di testo nellahelloworld directory e assegnagli un nomeDockerfile. Copia e incolla i contenuti seguenti:

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

Il Dockerfile che hai appena creato è un set di istruzioni utilizzato per creare immagini Docker. Leggi i commenti perDockerfile avere un'idea di ciò che viene costruito e adattalo se necessario alle tue esigenze. Per facilitare lo sviluppo, siDockerfile basa sulle immagini Docker ROS ufficiali gestite dalla Open Source Robotics Foundation (OSRF). Tuttavia, in fase di produzione, è possibile scegliere di creare l'immagine di base ROS con le istruzioni sorgente OSRF impostate GitHub per evitare l'impatto delle modifiche apportate a monte.

Quindi, crea un nuovo file chiamatoentrypoint.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}"

UnENTRYPOINT file è un eseguibile che viene eseguito quando viene generato il contenitore Docker. Stiamo usando un punto di ingresso per creare l'area di lavoro ROS, in modo da poter eseguire facilmenteroslaunch i comandiAWS RoboMaker. Potresti voler aggiungere i tuoi passaggi di configurazione dell'ambiente a questoENTRYPOINT file.

Il nostroDockerfile utilizza una compilazione multi-fase e una memorizzazione nella cache integrata con Docker BuildKit. Le build a più fasi consentono flussi di lavoro con fasi di compilazione separate, quindi le dipendenze di compilazione e il codice sorgente non vengono copiati nell'immagine di runtime. Ciò riduce le dimensioni dell'immagine Docker e migliora le prestazioni. Le operazioni di caching velocizzano le build future archiviando i file creati in precedenza.

Creare l'applicazione robotica con il seguente 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

Dopo aver creato l'applicazione robotica, è possibile creare l'applicazione di simulazione come segue:

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

Esegui il comandodocker images per confermare che le immagini Docker sono state create correttamente. L'output deve essere simile al seguente:

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

A questo punto, hai creato con successo le immagini Docker. È una buona idea testarli localmente prima di caricarli per utilizzarliAWS RoboMaker. La sezione seguente descrive come eseguire questa operazione.

Verificare le autorizzazioni

I comandi seguenti consentono di eseguire l'applicazione nell'ambiente di sviluppo locale.

Avvia l'applicazione del 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

Avvia l'applicazione di simulazione:

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

Dopo aver verificato il corretto funzionamento dei contenitori, puoi pubblicare i contenitori delle applicazioni su Amazon ECR e quindi inviare un processo di simulazione.