AWS App Runner Introduction

In this article, we will take a look at an overview of AWS App Runner. For this, we will deploy a “Hello World” demonstration, and finally we will present a review including its advantages and disadvantages.


Summary :

  1. What is AWS App Runner ?
  2. AWS App Runner Features
  3. App Runner use cases
  4. Pricing
  5. Tutorial
    • Why using AWS copilot ?
    • Getting started with the demo
    • Overview of different types of services 
  6. Pros and Cons of AWS App Runner

1 – What is App Runner ? 

App Runner is a service introduced by aws in May 2021 to allow developers to quickly deploy their application, without having to worry about managing the application’s infrastructure and especially without the need for any prior infrastructure experience.

2 – Features

  • Auto scalability depending on the traffic requirement and based on configurable min and max limits
  • Secure & encrypted traffic with SSL 
  • Load Balancing 
  • Easy & simple communication between the aws services within the same VPC as the deployed application

3 – Use cases 

  • Front-end and back-end web applications
  • Microservices and APIs
  • Rapid production deployments

4 – Pricing 

For automatic deployment, you will get paid for $ 1 per application per month and for build you will be charged $0.005 per minute.

5 – Tutorial

App runner supports two deployment modes; build and container mode.

  • Build mode: AWS pulls the code from GitHub and builds the application with each change.
  • Container mode: it deploys Docker-compatible images from public or private AWS ECR registries.

For our demo, we will go for a containerized application created using aws copilot service.

Prerequisites

  • AWS Copilot 
  • AWS CLI
  • AWS Console

Why using AWS copilot ?

AWS copilot enables customers to quickly launch and easily manage containerized applications on AWS. 

Then using the uri of the container image provided by the aws copilot, we use it to create our app runner service which will deploy the application on every new version of the container image or on every push when it is a build mode (using a source code and not based on the container image).

Getting started with the demo

  1. Clone the demo application 
git clone https://github.com/aws-samples/amazon-ecs-cli-sample-app.git demo-app

cd demo-app  
  1. Set up the App

Starting by running the init command and naming the application

copilot init 
What would you like to name your application? [? for help]
=> Enter Demo

Setting up an ECS service in the demo application

Which service type best represents your service's architecture? [Use arrows to move, type to filter, ? for more help]
   > Load Balanced Web Service
     Backend Service
     Scheduled Job
	=> Choose Load Balanced Web Service

Provide a name for the service

What do you want to name this Load Balanced Web Service? [? for help]
=> Enter api

Select a Dockerfile

Which Dockerfile would you like to use for api? [Use arrows to move, type to filter, ? for more help]
   > ./Dockerfile
     Use an existing image instead
=> Choose a Dockerfile

Define port 

=> Enter 80 or accept default

After the application resources are created, deploy a test environment and you will see a log displaying the status of the application deployment.

Finally, try accessing your application by accessing the URL provided by copilot:

Note:  in order to clean up the previously created resources, you can use 

copilot app delete

Overview of different types of services 

  1. Request Drive Web Service: used when you have a service with low request or you need to manage burst requests.
  2. Load Balanced Web Service: this creates a service equipped with a load balancer and public endpoint that you can access.
  3. Backend Service: creates a private service that you can only access within your application.
  4. Worker Service: this type of service covers the implementation of asynchronous communication with pub/sub for microservices architecture.
  5. Scheduled Job: this type is for building jobs that are triggered by events.

After getting the uri of the container image, we can create our app runner service which we will do with the AWS Console.

First, we will choose the containerized mode and we will provide the uri of the container image.

In a second step we will specify the deployment trigger if it will be manual or automated, 

and we need to grant the app runner with permissions in order to pull the container image from the ECS repository.

At this stade, we choose the service name and the virtual CPU and memory parameters

Finally, we have got the default domain where we can see our application deployed.

6 – Pros and cons of AWS App Runner 

This service is super smart as it helps developers to easily and quickly deploy their applications, however it definitely has some points that need to be further developed and perfected. In the following section, we give an overview of the advantages and disadvantages of this service.

Pros

  • Easy to use
  • Scales with traffic
  • Saves time

Drawbacks

  • Unable to extract an image outside the ECR
  • Unable to use the secret manager
  • Supports only Python and Node.js in build mode
  • Only GitHub is supported as a source code repository 

Conclusion

App Runner is a service that sits in the middle space between AWS Fargate, Lambda and ECS. It focuses on developer productivity and is a great way to get started with containerized applications.

Do you have a cloud project?