Use AWS App Runner, DynamoDB and CDK to deploy and run a Cloud native Go app

Earlier, I wrote a few Serverless URL shortener utility on AWS utilizing DynamoDB, AWS Lambda and API Gateway.

On this weblog submit, we’ll deploy that as a REST API on AWS App Runner and proceed to make use of DynamoDB because the database. AWS App Runner is a compute service that makes it straightforward to deploy functions from a container picture (or supply code), handle their scalability, deployment pipelines and extra.

With the assistance of a sensible instance offered on this weblog, you’ll:

• Find out about AWS App Runner, how you can combine it with DynamoDB
• Run easy benchmarks to discover the scalability traits of your App Runner service in addition to DynamoDB
• Apply “Infrastructure-as-Code” with AWS CDK Go and deploy your complete stack, together with the database, utility and different AWS assets.
• Additionally see the DynamoDB Go SDK (v2) in motion and among the primary operations reminiscent of PutItem, GetItem.

Let’s begin by deploying the URL shortener utility

Earlier than you start, ensure you have the Go programming language (v1.16 or increased) and AWS CDK put in.

Clone the venture and alter to the correct listing:

git clone https://github.com/abhirockzz/apprunner-dynamodb-golang
cd cdk

To begin the deployment…

Run cdk deploy and supply your affirmation to proceed. The next sections will present a stroll via of the CDK code so that you can higher perceive what is going on on.

cdk deploy

It will begin creating the AWS assets required for our utility.

If you wish to see the AWS CloudFormation template which might be used behind the scenes, run cdk synth and examine the cdk.out folder

You may maintain observe of the progress within the terminal or navigate to AWS console: CloudFormation > Stacks > DynamoDBAppRunnerStack

As soon as all of the assets are created, you need to have the DynamoDB desk, the App Runner Service (together with the associated IAM roles and so forth.).

URL shortener service on App Runner

You need to see the touchdown web page of the App Runner service that was simply deployed.

Additionally have a look at the Service Settings beneath Configuration which reveals the atmosphere variables (configured at runtime by CDK) in addition to the compute assets (1 VCPU and a pair of GB) that we specified

Our URL shortener is prepared!

The applying is comparatively easy and exposes two endpoints:

1. To create a brief hyperlink for a URL
2. Entry the unique URL through the brief hyperlink

To check out the applying, it is advisable to get the endpoint URL supplier by the App Runner service. It is out there within the stack output (within the terminal or the Outputs tab within the AWS CloudFormation console to your Stack):

First, export the App Runner service endpoint as an atmosphere variable,

export APP_URL=<enter App Runner service URL>

# instance
export APP_URL=https://jt6jjprtyi.us-east-1.awsapprunner.com

Invoke it with a URL that you just need to entry through a brief hyperlink.

curl -i -X POST -d 'https://abhirockzz.github.io/' $APP_URL

# output
HTTP/1.1 200 OK
Date: Thu, 21 Jul 2022 11:03:40 GMT
Content material-Size: 25
Content material-Kind: textual content/plain; charset=utf-8

{"ShortCode":"ae1e31a6"}

You need to get a JSON response with a brief code and see an merchandise within the DynamoDB desk as nicely:

You may proceed to check the applying with just a few different URLs.

To entry the URL related to the brief code

… enter the next in your browser http://<enter APP_URL>/<shortcode>

For instance, whenever you enter https://jt6jjprtyi.us-east-1.awsapprunner.com/ae1e31a6, you can be re-directed to the unique URL.

You may also use curl. Right here is an instance:

export APP_URL=https://jt6jjprtyi.us-east-1.awsapprunner.com

curl -i $APP_URL/ae1e31a6

# output
HTTP/1.1 302 Discovered
Location: https://abhirockzz.github.io/
Date: Thu, 21 Jul 2022 11:07:58 GMT
Content material-Size: 0

Auto-scaling in motion

Each App Runner and DynamoDB are able to scaling up (and down) in line with workload.

AWS App Runner

AWS App Runner robotically scales up the variety of cases in response to a rise in site visitors and scales them again when the site visitors decreases.

That is based mostly on AutoScalingConfiguration which is pushed by the next user-defined properties – Max concurrency, Max measurement and Min measurement. For particulars, seek advice from Managing App Runner automated scaling

Right here is the auto-scale configuration for the URL shortener App Runner Service:

DynamoDB

In case of On-demand mode, DynamoDB immediately accommodates your workloads as they ramp up or right down to any beforehand reached site visitors degree. Provisioned mode requires us to specify the variety of reads and writes per second that you just require to your utility, however you should utilize auto scaling to regulate your desk’s provisioned capability robotically in response to site visitors modifications.

Lets run some assessments

We will run a easy benchmarks and witness how our service reacts. I might be utilizing a load testing software known as hey however it’s also possible to do use Apache Bench and so forth.

Here’s what we’ll do:

1. Begin off with a easy take a look at and study the response.
2. Ramp up the load such that it breaches the provisioned capability for the DynamoDB desk.
3. Replace the DynamoDB desk capability and repeat.

Set up hey and execute a primary take a look at – 200 requests with 50 staff concurrently (as per default settings):

hey $APP_URL/<enter the brief code>

#instance
hey https://jt6jjprtyi.us-east-1.awsapprunner.com/ae1e31a6

This ought to be nicely throughout the capability of our stack. Let’s bump it to 500 concurrent staff to execute requests for a sustained interval of 4 minutes.

hey -c 500 -z 4m $APP_URL/<enter the brief code>

#instance
hey -c 500 -z 4m https://jt6jjprtyi.us-east-1.awsapprunner.com/ae1e31a6

How is DynamoDB doing?

In DynamoDB console beneath Desk capability metrics, examine Learn utilization (common items/second):

Extra importantly, examine Learn throttled occasions (rely):

Since our desk was in Provisioned capability mode (with 5 RCU and WCU), the requests received throttled and a few of them failed.

Edit the desk to alter its mode to On-demand, re-run the load take a look at. You shouldn’t see throttling errors now since DynamoDB will auto-scale in response to the load.

What about App Runner??

Within the Metrics seton in App Runner console, examine the Energetic Situations rely.

You may also observe the opposite metrics and experiment with numerous load capacities

Alright, now that you’ve got truly seen what the applying does and examined the fundamental scalability traits of the stack, let’s transfer on to the how.

However, earlier than that….

Remember to delete assets

When you’re performed, to delete all of the companies, merely use:

cdk destroy

AWS CDK code stroll via…

We are going to undergo the keys elements of the NewDynamoDBAppRunnerStack perform which defines your complete stack required by the URL shortener utility (I’ve omitted some code for brevity).

You may seek advice from the entire code on GitHub

We begin by defining a DynamoDB desk with shorturl because the Partition key (Vary/Kind key just isn’t required for our case). Be aware that the BillingMode attribute decides the desk capability mode, which is Provisioned on this case (with 5 RCU and WCU). As demonstrated within the earlier part, this was chosen on objective.

func NewDynamoDBAppRunnerStack(scope constructs.Assemble, id string, props *DynamoDBAppRunnerStackProps) awscdk.Stack {
  //....
    dynamoDBTable := awsdynamodb.NewTable(stack, jsii.String("dynamodb-short-urls-table"),
        &awsdynamodb.TableProps{
            PartitionKey: &awsdynamodb.Attribute{
                Title: jsii.String(shortCodeDynamoDBAttributeName),
                Kind: awsdynamodb.AttributeType_STRING,
            },
            BillingMode:   awsdynamodb.BillingMode_PROVISIONED,
            ReadCapacity:  jsii.Quantity(5),
            WriteCapacity: jsii.Quantity(5),
            RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
        })
  //...

Then, we use awsiam.NewRole to outline a brand new IAM position and in addition add a coverage that enables App Runner to execute actions in DynamoDB. On this case we offer granular permissions – GetItem and PutItem.

//...
apprunnerDynamoDBIAMrole := awsiam.NewRole(stack, jsii.String("role-apprunner-dynamodb"),
        &awsiam.RoleProps{
            AssumedBy: awsiam.NewServicePrincipal(jsii.String("duties.apprunner.amazonaws.com"), nil),
        })

apprunnerDynamoDBIAMrole.AddToPolicy(awsiam.NewPolicyStatement(&awsiam.PolicyStatementProps{
        Impact:    awsiam.Effect_ALLOW,
        Actions:   jsii.Strings("dynamodb:GetItem", "dynamodb:PutItem"),
        Sources: jsii.Strings(*dynamoDBTable.TableArn())}))

awsecrassets.NewDockerImageAsset permits to create and push our utility Docker picture to ECR – with a single line of code.

//...
appDockerImage := awsecrassets.NewDockerImageAsset(stack, jsii.String("app-image"),
        &awsecrassets.DockerImageAssetProps{
            Listing: jsii.String(appDirectory)})

As soon as all of the items prepared, we outline the App Runner Service. Discover the way it references the knowledge required by the applying:

• The title of the DynamoDB desk (outlined beforehand) is seeded as TABLE_NAME env var (required by the applying)
• The Docker picture that we outlined is instantly utilized by the Asset attribute
• The IAM position that we outlined is hooked up to the App Runner service as Occasion Position

The occasion position is an non-obligatory position that App Runner makes use of to offer permissions to AWS service actions that your service’s compute cases want.

Be aware that that an alpha model (on the time of writing) of the L2 App Runner CDK assemble has been used and that is a lot easy in comparison with the CloudFormation based mostly L1 assemble. It affords a handy NewService perform with which you’ll outline the App Runner Service together with the supply (domestically out there on this case), the IAM roles (Occasion and Entry) and so forth.

//...
app := awscdkapprunneralpha.NewService(stack, jsii.String("apprunner-url-shortener"),
        &awscdkapprunneralpha.ServiceProps{
            Supply: awscdkapprunneralpha.NewAssetSource(
                &awscdkapprunneralpha.AssetProps{
                    ImageConfiguration: &awscdkapprunneralpha.ImageConfiguration{Atmosphere: &map[string]*string{
                        "TABLE_NAME": dynamoDBTable.TableName(),
                        "AWS_REGION": dynamoDBTable.Env().Area},
                        Port: jsii.Quantity(appPort)},
                    Asset: appDockerImage}),
            InstanceRole: apprunnerDynamoDBIAMrole,
            Reminiscence:       awscdkapprunneralpha.Memory_TWO_GB(),
            Cpu:          awscdkapprunneralpha.Cpu_ONE_VCPU(),
        })

    app.ApplyRemovalPolicy(awscdk.RemovalPolicy_DESTROY)

Wrap up

This brings us to the top of this weblog submit! You explored a URL shortener utility that uncovered REST APIs, used DynamoDB as its persistent retailer and deployed it to AWS App Runner. Then we checked out how the person companies scaled elastically in response to the workload. Lastly, we additionally explored the AWS CDK code that made is feasible to outline the applying and its infrastructure as (Go) code.

Pleased constructing!