Build headless robotic simulations with AWS Batch

Introduction

Headless robotic simulations with AWS Batch permit robotic builders to extend their velocity by operating their code via 1000’s of eventualities and iterating earlier than shifting onto bodily system testing. The true-world environments and conditions a robotic can discover itself in are almost countless. What’s worse, it’s time consuming and dear to deploy and check each situation on bodily robots. AWS Batch is a service that offers robotic builders a simple option to run batch robotics simulation at large scale with customized management of what compute varieties to make use of.

Be aware that AWS Batch is finest used for operating headless batch simulations at scale. If you’re searching for interactive simulations with a GUI, we advocate AWS RoboMaker simulation.

Overview

On this weblog, you’ll create an AWS Batch compute surroundings and job to run your containerized robotic and simulation purposes. This weblog takes the Amazon CloudWatch robot monitoring sample initially constructed with AWS RoboMaker and updates it to point out how one can accomplish the duty with AWS Batch as a substitute. The pattern runs a robotic navigation check and sends information to Amazon CloudWatch to watch the robotic’s place and velocity.

We’ll undergo the next steps:

1. Put together robotic and simulation containers.
2. Create a Dockerfile to put in docker-compose and the AWS Command Line Interface (AWS CLI).
3. Construct and push the container picture to Amazon Elastic Container Registry (Amazon ECR).
4. Create a docker-compose.yaml file and add it to Amazon Simple Storage Service (Amazon S3).
5. Arrange permissions to your AWS Batch jobs and robotic and simulation purposes.
6. Create an AWS Batch compute surroundings, job queue, job definition, and job utilizing the AWS Batch Wizard.
7. View the logs in Amazon CloudWatch.

Conditions:

The next are necessities to comply with together with this weblog:

• An AWS account with permissions to AWS Identity and Access Management (AWS IAM), Amazon S3, Amazon ECR, Amazon CloudWatch, and AWS Batch.
• Fundamental understanding of Docker containers.
• Docker, the AWS CLI, and the VCS Instrument put in in your machine.
  • Find out how to set up the AWS CLI: https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html
  • Find out how to set up Docker: https://docs.docker.com/get-docker/
  • Find out how to set up the VCS Import Tool:

    sudo pip3 set up vcstool

Put together your robotic and simulation containers

This weblog takes the Amazon CloudWatch robot monitoring sample initially constructed with AWS RoboMaker and updates it to point out how one can accomplish the duty with AWS Batch as a substitute. This part refers to content material in a previous blog and paperwork the required adjustments so the containers will work with AWS Batch.

1. Clone the Amazon CloudWatch robot monitoring sample repository
   Be aware: Within the AWS Robotics pattern purposes, the code is already structured with ROS workspace directories. Due to this fact, you don’t have to create a workspace and supply code listing. Nevertheless, for many open-source ROS packages and certain to your code, first create your workspace listing and clone the supply code into /src.

   git clone https://github.com/aws-robotics/aws-robomaker-sample-application-cloudwatch.git cloudwatchsample && cd cloudwatchsample

2. Containerize the robotic and simulation purposes by following the steps described in Preparing ROS application and simulation containers for AWS RoboMaker with some minimal title adjustments. Begin from Construct a docker picture from a ROS workspace for AWS RoboMaker step 2.
   1. In step 3, place the Dockerfile within the cloudwatchsample listing.
   2. In step 6 and seven chances are you’ll select to rename your purposes to cloudwatch-robot-app and cloudwatch-sim-app You might also select to rename your software tags as batch-cloudwatch-robot-app and batch-cloudwatch-sim-app respectively.
   3. Below step 1 of Publish docker pictures to Amazon ECR, make sure you use the identical robotapp and simapp variables as your software tag names from steps 6 and seven.
3. Cease when you could have pushed your ROS-based robotic and simulation docker pictures to Amazon ECR (simply earlier than you get to the part titled: Create and run robotic and simulation purposes with containers in AWS RoboMaker).

Create a Dockerfile to put in docker-compose and the AWS CLI

We’ll launch each the robotic and simulation containers in AWS Batch. This lets you run each containers on the identical time and have them talk with one another. So as to have this course of run at scale, we could have a particular Docker container that AWS Batch makes use of to run the docker-compose file. The Docker container will need to have the AWS CLI put in to obtain the docker-compose file from Amazon S3, and now have Docker Compose put in with a view to run the docker-compose up command for creating and beginning the robotic and simulation containers.

1. Contained in the cloudwatchsample folder, create a brand new folder for storing our AWS Batch Docker information.

   mkdir batch-docker && cd batch-docker

2. Create a brand new file named Dockerfile and replica the contents beneath into the file. This Dockerfile installs Docker Compose and the AWS CLI. This can then assist you to run a command so AWS Batch can copy your docker-compose.yaml object from Amazon S3.
   Dockerfile:

   FROM ubuntu:focal
   ARG DEBIAN_FRONTEND=noninteractive
   # Set up conditions
   RUN apt-get replace && apt-get set up -y curl && apt-get set up wget
   RUN apt-get replace && apt-get -y set up awscli
   RUN apt -y set up amazon-ecr-credential-helper
   RUN apt-get -y set up jq
   RUN mkdir ~/.docker && echo "{"credsStore": "ecr-login"}" | jq > ~/.docker/config.json
   RUN curl -L "https://github.com/docker/compose/releases/obtain/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/native/bin/docker-compose
   RUN chmod +x /usr/native/bin/docker-compose
   RUN ln -s /usr/native/bin/docker-compose /usr/bin/docker-compose

Construct and push the container picture to Amazon ECR.

We at the moment are going to make use of the console to create an Amazon ECR repository after which construct and push the Docker picture to the repository.

1. Create a repository in Amazon ECR. Within the Amazon ECR console, from the navigation menu, select Repositories, Create repository. Hold your repository non-public and provides it a reputation similar to batch-dockercompose-awscli. Select, Create repository.
2. Choose your new repository and select View push instructions. This opens a window that gives you the AWS CLI instructions to execute to construct and push your container picture to Amazon ECR.
   Be aware: If you’re operating the push instructions from a non-linux platform, you will want to replace the docker construct command to incorporate --platform linux/amd64 on the finish.
   The total command shall be: docker construct -t batch-dockercompose-awscli . --platform linux/amd64

Create a docker-compose.yaml file and add it to Amazon S3

1. Create a docker-compose.yaml file and replica the contents beneath into the file. The file will run each the robotic and simulation software and move via the correct permissions.

   model: "3"
   providers:
     robotic:
       picture: .dkr.ecr..amazonaws.com/batch-cloudwatch-robot-app
       network_mode: host
       command: bash -c "sudo apt-get -y improve && roslaunch cloudwatch_robot rotate.launch"
       surroundings:
               - AWS_CONTAINER_CREDENTIALS_RELATIVE_URI
               - TURTLEBOT3_MODEL
     sim:
       picture: .dkr.ecr..amazonaws.com/batch-cloudwatch-sim-app
       network_mode: host
       command: roslaunch cloudwatch_simulation bookstore_turtlebot_navigation.launch
       surroundings:
               - AWS_CONTAINER_CREDENTIALS_RELATIVE_URI
               - TURTLEBOT3_MODEL
   

2. Replace the picture entries within the docker-compose.yaml with the suitable picture URI for each the robotic and simulation purposes from Amazon ECR that you simply created earlier. You will discover the picture URIs within the Amazon ECR console subsequent to your repository names. The docker-compose.yaml file units network_mode to host for each containers so the containers can talk with one another and supplies the suitable instructions to launch the purposes. It additionally units the surroundings variables mandatory to your purposes. As a result of this software wants AWS permissions (to entry Amazon CloudWatch logs and metrics), use the AWS_CONTAINER_CREDENTIALS_RELATIVE_URI variable to move your AWS permissions to your containers. All of your containers could have the identical permissions. This software additionally requires the TURTLEBOT3_MODEL variable to be set, so it’s handed in as an surroundings variable in your docker-compose file as properly.

3. Within the Amazon S3 console, select an present bucket, or create a brand new bucket to add your docker-compose.yaml file to. Choose the bucket, select Add, drag and drop your docker-compose.yaml file or select Add information, and navigate to your file. Select Add. As soon as the article is uploaded, select Shut, then choose your docker-compose.yaml object, and select Copy S3 URI to repeat your URI for future use.

Arrange permissions to your AWS Batch jobs and robotic and simulation purposes

First, create an Amazon Elastic Container Service (Amazon ECS) Activity Execution position.

1. Navigate to the AWS IAM Console. Within the navigation menu, select Roles, then select Create position.
2. On Step 1, choose the AWS service Trusted entity kind. For Use case, select Elastic Container Service from the drop down, then choose Elastic Container Service Activity. Select Subsequent.
3. On Step 2, Add Permissions, you grant Amazon ECS brokers permission to name AWS APIs in your behalf. AWS has a managed coverage already created for this job. For the Permissions insurance policies, seek for after which select the test field to the left of AmazonECSTaskExecutionRolePolicy. Select Subsequent.
4. For Position Title, enter ecsTaskExecutionRole, after which select Create position.

Subsequent, it’s essential create a job execution position that offers the containers permissions to entry the docker-compose.yaml file in Amazon S3, retrieve the docker pictures from Amazon ECR, and use Amazon CloudWatch logs for the CloudWatch pattern software to run.

1. Navigate to the AWS IAM Console. Within the navigation menu, select Roles, then select Create position.
2. Choose the AWS service Trusted entity kind. For Use case, select Elastic Container Service from the drop down, then choose Elastic Container Service Activity. Select Subsequent.
3. Select Create coverage to pop open a brand new tab for IAM coverage creation.
4. On the Create Coverage web page, select JSON, and replica paste the next within the textual content field.

   {
       "Model": "2012-10-17",
       "Assertion": [
           {
               "Effect": "Allow",
               "Action": "cloudwatch:PutMetricData",
               "Resource": "*"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "logs:DescribeLogGroups",
                   "logs:DescribeLogStreams",
                   "logs:CreateLogGroup"
               ],
               "Useful resource": [
                   "arn:aws:s3:::/docker-compose.yaml",
                   "arn:aws:logs:us-west-2::log-group:robomaker_cloudwatch_monitoring_example:log-stream:*"
               ]
           }
       ]
   }

5. Replace the coverage to have the correct assets. When you’ve got been following together with these instructions, you simply have to replace the and . You will discover the bucket title by going to the Amazon S3 console and discovering the bucket you created above.
6. Select Subsequent: Tags, then select Subsequent: Evaluation.
7. Title the coverage ecspolicy-batch-cloudwatchsample. Select Create coverage.
8. Shut the IAM coverage tab to return to the IAM position creation tab.
9. For Permissions insurance policies, seek for after which select the test field to the left of AmazonECSTaskExecutionRolePolicy (that is wanted so your robotic and simulation containers might be pulled from Amazon ECR) and your newly created ecspolicy-batch-cloudwatchsample (Be aware: You could want to decide on the coverage refresh button for it to replace together with your new coverage).
10. Select Subsequent.
11. For Position Title, enter ecsJobRole-cloudwatchsample, give it a Description, after which select Create position.

Create an AWS Batch compute surroundings, job queue, job definition, and job utilizing the AWS Batch Wizard

Now you’ll arrange AWS Batch to execute the Docker containers we created above to run your simulation. To begin, navigate to the AWS Batch Console in AWS and select Wizard within the left menu. This can information you thru creating the required assets and operating the job.

Step 1: Create a compute environment.

1. Give your compute surroundings a reputation.
2. Go away the default Service position as Batch service-linked position.
   
3. Set the Occasion Configuration to On-demand. This can create Amazon Elastic Compute Cloud (Amazon EC2) cases for you while you run your jobs. You may additionally choose Spot right here to avoid wasting cash with Amazon EC2 Spot Instances.
4. Go away the Minimal, Most, and Desired vCPUs because the default. By leaving the minimal CPU set to zero, AWS Batch is not going to have any idle EC2 cases. This implies the primary job execution is slower, however you additionally don’t incur any prices till you run the job and assets are consumed. Rising the minimal and desired variety of vCPUs heat pool of EC2 cases and helps cut back the time to begin jobs, however does eat extra assets.
5. Below Allowed occasion varieties, you possibly can choose optimum to best-fit the occasion kind to your job definition. For those who desire, you can too manually choose the occasion kind you wish to use.
6. Go away the Allocation technique because the default, BEST_FIT.
   
7. The default Networking settings might be left as is.
8. Select Subsequent.

Step two: The job queue. This allows you to create job queues tied to completely different compute environments and helps with prioritization/orchestration. You may go away this because the default and select Subsequent.

Step three: The job definition. This defines the container picture and configuration to make use of within the job. Right here you will want to set the next:

1. A Title to your job definition.
2. An Execution Timeout. You may set this to 3600 (1 hour).
3. For execution position, select the IAM position you created within the earlier part, ecsTaskExecutionRole.
   
4. Below Job Configuration, add your container picture ECR URI to your container picture that installs docker-compose and the AWS CLI. For those who had been following alongside it needs to be named:

   .dkr.ecr..amazonaws.com/batch-dockercompose-awscli

5. Substitute and with the suitable values.
6. For Command, enter the next command which downloads your docker-compose.yaml file from Amazon S3, units the TURTLEBOT3_MODEL variable, after which calls docker-compose up to begin your robotic and simulation containers.

   bash -c 'aws s3 cp  . && export TURTLEBOT3_MODEL=waffle_pi && docker-compose up'
   

7. Ensure that to exchange together with your S3 URI, which can look much like:

   s3:///docker-compose.yaml

9. Go away the remaining as default for now and select Subsequent.

 Step 4: The job creation

1. Set the Execution Timeout to 3600 (1 hour). The remainder of the wizard web page needs to be pre-filled out of your job definition.
2. Select Subsequent: Evaluation, and select Create.

Run an AWS Batch Job

First, we’re going to create the Job Definition.

1. Navigate to the AWS Batch Console in AWS and open Job definitions from the navigation menu. Choose the radio button subsequent to the job definition you simply created, then press Create revision.
2. Go away Step 1: Job definition configuration as-is and select Subsequent web page.
3. In Step 2: Container configuration, set Job position configuration to ecsJobRole-cloudwatchsample, the position you created earlier to present the container in your job with permissions to make use of the AWS APIs and to mount the docker socket from the underlying host. Select Subsequent web page.
4. In Step 3: Linux and logging settings, set the Linux configuration to Person: root and switch Privileged on to present the container elevated privileges on the host container occasion.
5. Within the Filesystem configuration settings, broaden Extra configuration and replace Volumes configuration:
   1. Select Add quantity.
   2. Title: dockersock, Supply path: /var/run/docker.sock
6. Subsequent, set the Mount factors configuration:
   1. Select Add mount factors configuration.
   2. Supply quantity: dockersock, Container path: /var/run/docker.sock
7. Select Subsequent web page.
8. In Step 4: Job definition assessment, assessment that you simply configuration has the correct settings:
   
9. Select Create job definition.

Now you possibly can execute the job definition you simply created.

1. Within the navigation menu, select Jobs. Select Submit new job.
2. Give your job a reputation after which select the newest revision of your Job definition. Select your Job queue that you simply created with the wizard.
3. Select Subsequent web page after which Subsequent web page
4. Select Create job.

Be aware: It would take a couple of minutes to your job to be within the STARTING state. It is because we didn’t arrange a heat pool of cases so AWS Batch wants to begin up cases to run the job.

View the logs

1. As soon as your job is within the Working state, scroll all the way down to Job info and select the Log stream title.
2. A brand new tab will open to Amazon CloudWatch the place you possibly can see logs out of your AWS Batch lab.
3. If you’re following together with the CloudWatch Monitoring instance, you can too see logs coming via out of your robotic software.
4. From the Amazon CloudWatch console, select Log teams and seek for a log group named robomaker_cloudwatch_monitoring_example. If you don’t see the log group, select your area from the navigation bar and select US West (Oregon) us-west-2 (that is the area set within the configuration file of the robotic software operating contained in the container).
5. Select the turtlebot3 log stream.

Right here you need to see logs coming in out of your robotic software. You may also see the metrics from the robotic in Amazon CloudWatch by selecting Metrics, All metrics from the navigation menu. Select Customized namespaces, robomaker-cloudwatch-monitoring-example, class, robotid. Set the interval of the logs to 1 second so you possibly can simply visualize them on the graph.

Congratulations! You might have efficiently run a headless robotics simulation with AWS Batch.

Clear-up

To take away assets from AWS Batch:

1. Within the AWS Batch console, choose Jobsfrom the navigation menu.
2. Select your Job queue,then select Search.
3. Choose any jobs you could have created and select Terminate job.
4. Choose Job definition from the navigation menu.
5. Choose your job definitions, after which select Deregister, Deregister job definition.
6. Choose Job queues from the navigation menu.
7. Choose your job queue, select
8. Choose Compute environments from the navigation menu.
9. Choose your compute surroundings, select

To take away assets from Amazon ECR:

1. Within the Amazon ECR console, select Repositories.
2. Choose every of the three repositories and select Delete. Kind delete to substantiate deletion.

To take away assets from Amazon S3:

1. Within the Amazon S3 console, select Buckets.
2. Choose your bucket, and select Kind completely delete and select Empty to substantiate deletion.
3. Select Exit.
4. Choose your bucket once more, and select Delete. Kind the bucket title and select Delete bucket to substantiate deletion.

To take away assets from Amazon CloudWatch:

1. Within the Amazon CloudWatch console, select Logs, Log teams.
2. Choose the log streams used for this weblog and select Delete, Delete. (Be aware: a few of your logs could also be in your authentic area and a few shall be in us-west-2).

Abstract

On this weblog, you discovered how you should utilize AWS Batch to run headless robotic simulations at scale. Utilizing AWS Batch for simulations at scale provides you customized management and value financial savings to your simulation workloads. We sit up for listening to extra about your simulation workloads operating at scale.