Forem: Jose Hidalgo

Cloud Portfolio Challenge: Load balancing and content delivery network

Jose Hidalgo — Mon, 13 Jun 2022 01:48:56 +0000

The problem

Build an image delivery service that, when queried, returns at least one image matching the search criteria of your choice

Solution design

The solution in Figure 1 demonstrates how I build the image delivery system using Amazon CloudFront, Amazon Load Balancer, and Amazon Auto-scaling group.

The 4 key points that I learned from this project are:

Virtual machines
Networking
Load balancing
Content delivery networks (CDNs)

Figure 1 illustrates the architecture of this solution.

The user will access the site using the CloudFront URL. Amazon CloudFront works seamlessly with Amazon EC2 to accelerate the delivery of the dynamic content. You can specify which AWS origins you would like. The AWS origins we can use are Amazon S3, Amazon EC2, or Elastic Load Balancing. When I set up the CloudFront, I specified the load balancing DNS name as the AWS origin. Before I go on about how I set up the public-facing load balancer one of the reasons we want to use CloudFront on a web application is because using a traditional server-based approach can add more load to the web server. With CloudFront, the end-users connection is terminated at CloudFront edge locations closer to them, which helps to reduce the overall round trip required to establish a connection. Without CDN the user would have to connect to the origin server. However, with CDN, the user connects to the nearest CloudFront location where the data is cached for the next users.
I set up an internet-facing load balancer with private subnets used by Amazon EC2 instances. Then, associate the public subnets with the load balancer. It was really straightforward to do. This website helped me a lot. One of the key benefits of using a load balancer vs an API Gateway is the ability to distribute load intelligently across resources. This makes them ideal when using services such as Amazon EC2 or Amazon ECS, where a single instance or task could become non-operational if flooded with requests.
I registered an autoscaling group to the load balancer. I could have used the load balancer without the autoscaling group but I preferred to give it a try to know how to set up one as it was my first time using one. Auto-scaling is an automated process that adjusts capacity for predictable performance and costs. To define auto-scaling to EC2 instances, there are two ways to do it. We can either use Launch Configurations or Launch Template. In the project, I used Launch Configuration because of how easier was to do it but either way works. When we define the Launch Configuration, the auto-scaling group will use it to initiate our instances. Scaling is done automatically through a set of threshold parameters. We can scale up or down depending on what requirement we want, AWS Auto scaling allows us to also monitor the applications, and most importantly scaling is done automatically.
The EC2 instances are holding a web and an API application using NGINX.
1. The web application is a simple static application that has a search input that when entering some information and press search, makes a call to an API.
2. The API application is a python fast application that has an exposed endpoint /image/{image_name} when it gets called, it looks for images stored in the EC2 if there are one’s matching criteria it pulls the image otherwise it won’t show anything on the site.

A preview of how the web application works, download the video here.

Code repository

The code for this solution is available on Github.

Next Steps

Something that I have learned over the years is that there is no perfect architecture. While I was building this project I realized that there were some things that could have been better built in a different way, I’m going to mention those things that I would like to tackle for the future that will make the presented architecture stronger:

Use Amazon Elastic File System to store the images and decouple them from the EC2 instances. One of the reasons is that spinning an EBS is easy and EBS is a private service and can be shared between many EC2 instances.
Leverage storing the applications using Amazon ECS. By using ECS, we can focus on building the application rather than maintaining the infrastructure on which it will run. A major benefit of ECS is that it supports Docker containers. So we can have our application dockerized.

Conclusion

Cloud engineers that operate daily with bigger applications often struggle to think about how we can build highly scalable applications. This project opened my mind to dive deeper into these services: Amazon CloudFront, Amazon Load Balancer, and Amazon Auto-scaling group. How these services are connected and how they can improve the efficiency of a multi-tier application. These technologies not only offer automatic scaling and built-in high availability but provide a better user experience that is important for the end-user. I’d like to thank Lars Klint ****for creating this amazing project that taught me so many good things that I can use in my work. And most importantly, doing this project put me one step closer to taking the AWS Certified Solutions Architect Associate soon.

If you are as interested as I was and would like to get your hands dirty to learn cloud stuff, go to the site to learn more about the project requirements.

My approach building a serverless application that notifies me of gasoline prices

Jose Hidalgo — Tue, 19 Apr 2022 00:19:08 +0000

AWS offers a variety of products to create any application you can think of. With DynamoDB, you can trigger a Lambda function to perform additional work each time a DynamoDB table is updated.

In this post, I’ll show how these two technologies can work together. Without further ado, let’s get started.

What I'm building

NYC Open Data has a public API that details gasoline price information of all the New York Regions. A new gasoline price gets added every week.

I had the idea of building a system that can notify me of the gasoline prices with the condition when the price goes down. I’m going to show you how I did this. You might think the idea sounds a little vague or easy to do but the most important thing about the project is how I did it which is what I want to emphasize here in this blog.

Setting up the project

Getting your repository set up

I enjoy doing side projects with the latest trends in the market. In the project, I use terraform. For those of you that don’t know terraform is infrastructure as code that lets you build, change, and version cloud and on-premise resources safely and efficiently. In short words, instead of using the AWS UI, we use code to create AWS services.

Another cool technology that I’m using is Serverless. Serverless is a cloud-native development model that allows developers to build and run applications without having to manage servers. It’s really cool because we just need to provide the code and AWS will do all the heavy tasks in the background.

Building the infrastructure

Something I have learned over time using terraform is that I like to structure the different resources I want to build using modules. For example, if I’m planning to use an EC2 I normally create a compute module and allocate all the logics that falls in EC2. Here’s what I did:

module "dynamodb" {
  source = "./dynamodb"
}

module "sns" {
  source = "./sns"
  email  = var.email
}

module "lambda" {
  source                          = "./lambda"
  gasoline_prices_table_arn       = module.dynamodb.gasoline_prices_table_arn
  gasoline_price_table_stream_arn = module.dynamodb.dynamodb_stream_arn
  sns_arn                         = module.sns.sns_arn
}

Once we have the modules in place I start building each module separately and export any variable that a given module needs.

In AWS every resource that we want to create is private. If we want to execute a resource either programmatically or get access to it, we need to explicitly tell AWS to do it.

I created an IAM role in the lambda module to detail all the permissions that the Lambda needs.

resource "aws_iam_policy" "iam_role_policy_for_lambda" {

  name        = "aws_iam_policy_for_terraform_aws_lambda_role"
  description = "AWS IAM Policy for managing aws lambda role"
  policy = jsonencode({
    Statement = [{
      Action   = ["s3:GetObject", "s3:PutObject"],
      Effect   = "Allow",
      Resource = "${aws_s3_bucket.price_fetcher_deployment.arn}"
      },
      {
        Action   = ["dynamodb:Scan", "dynamodb:Query", "dynamodb:PutItem"],
        Effect   = "Allow",
        Resource = "${var.gasoline_prices_table_arn}"
      },
      {
        Action   = ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents", "logs:DescribeLogStreams", "logs:createExportTask"],
        Effect   = "Allow",
        Resource = "*"
      },
      {
        Action   = ["dynamodb:DescribeStream", "dynamodb:GetRecords", "dynamodb:GetShardIterator", "dynamodb:ListStreams"],
        Effect   = "Allow",
        Resource = "${var.gasoline_price_table_stream_arn}"
      },
      {
        Action = ["sns:Publish"],
        Effect   = "Allow",
        Resource = "${var.sns_arn}"
      }
    ]
    Version = "2012-10-17"
  })
}

As you can see above, we have explicitly told AWS which permissions my AWS needs to execute the Lambda. This is something that you have to think about as you continue adding functionalities to your Lambda.

If you wondered before why I was passing some variables to the lambda from the dynamodb module. In order to grant permission to our Lambda to execute queries in Dynamo DB. We need to get the reference of the table and explicitly add it to the policy.

Lambda and More

It only takes a few minutes to create a lambda using the serverless framework. Make sure you have the serverless package installed on your machine. Depending on what type of serverless template you want to create (e.g javascript, python) you specify it in the serverless CLI. For example

sls create --template aws-python3 --path myService

The serverless.yml is the heart of a serverless application. This file describes the entire application infrastructure, all the way from the programming language to resource access.

A few examples of properties we can use:

The functions we want to run
Environment variables
Depending on the cloud provider we’re using, we can specify the role and the region our code will get run on

For more information about this, check out this documentation.

Here’s what my YAML looks like:

service: aws-price-fetcher

frameworkVersion: "3"

provider:
  name: aws
  runtime: python3.8
  region: us-east-1
  deploymentBucket:
    name: price-fetcher-serverlessdeploymentbucket
  iam:
    role: arn:aws:iam::008735640664:role/Price-Notifier-Role

functions:
  price_fetcher:
    handler: handler.price_fetcher
    description: Fetches gasoline price from public API
    events:
      - schedule: cron(* * 0 ? * WED *)
  price_publisher:
    handler: handler.price_publisher
    description: Publish gasoline drops

plugins:
  - serverless-python-requirements

I won’t go to each one of the properties because some of them are self-explanatory.

service is the name of our lambda in AWS.

provider/region: Lambas are region-specific. What this means is that each Lambda function lives in a specific AWS region.

deploymentBucket: when we create a lambda our lambda has to live somewhere in AWS. This is why in terraform we are creating a bucket for our lambda to live in and by this means we need to specify it in the YAML file.

role The role created in terraform along with its permissions to execute resources in AWS.

functions: When we create a lambda we can have multiple functions living in one lambda. To make this project easy, I chose to have 1 lambda with 2 functions one for fetching the gasoline price from the public API and another one to publish the gasoline drops.

plugins are just the different libraries we are using in serverless. We're using serverless-python-requirements because we need some libraries to execute our code, for example, requests. If you’re curious to see more libraries, check out this documentation that details all the plugins serverless has.

In the lambda, I created a function called price_fetcher whose purpose is to query the DynamoDB table, if there are any records it gets the most recent gasoline price, calculates against the last record we have in the database if the price has dropped it insert the record to the table otherwise, it doesn’t do the insertion.

 def price_fetcher(event: Dict[str, Any], _: Any) -> None:
    """
    Fetches gasoline price from public API
    Calculate the most recent gasoline price with the last record saved in the DynamoDB table
    if the price has dropped, it inserts that record into the table otherwise, it skips it.
    """
    items = query(GASOLINE_PRICE_TABLE_NAME)
    LOG.info(f"Got items: {items}")

    gasoline_api_response = request()

    gasoline_api_json = gasoline_api_response.json()

    most_recent_gasoline_price: Dict = gasoline_api_json[0]
    LOG.info(f"Got most recent gasoline price: {most_recent_gasoline_price}")

    published_at = most_recent_gasoline_price['date']
    gasoline_price = most_recent_gasoline_price['new_york_state_average_gal']

    if items:
        previous_gasoline_price = float(items[0]['newYorkStateAverageGal'])
        LOG.info(f'Got previous previous_gasoline_price {previous_gasoline_price}')

        recent_gasoline_price = float(gasoline_price) 

        price_has_dropped = recent_gasoline_price < previous_gasoline_price

        if not price_has_dropped:
            LOG.info("Skipping insertion because price hasn't dropped")
            return

    response = insert(GASOLINE_PRICE_TABLE_NAME, published_at=published_at, gasoline_price=gasoline_price)
    LOG.info(f"Got response: {response}")

    return None

DynamoDB provides a Change Data Capture (CDC) mechanism for each table.

That means, if someone creates a new entry or modifies an item in a table, DynamoDB immediately emits an event containing the information about the change. You can build applications that consume these events and take action based on the contents.

DynamoDB keeps track of every modification to data items in a table and streams them as real-time events.

Here’s how I did it using terraform:

resource "aws_lambda_event_source_mapping" "gasoline_prices_stream" {
  event_source_arn  = aws_dynamodb_table.gasoline_prices_table.stream_arn
  function_name     = var.price_publisher_arn
  starting_position = "LATEST"
}

We need to provide a unique ARN that points to our table and indicates the function where we want to send these events.

Next, see how I’m getting the events from the Lambda:

def price_publisher(event: Dict[str, Any], _: Any) -> None:
    """
    Get DynamoDB events and send information to the user.
    """
    LOG.info(f'Got event {event}')
    record = event['Records'][0]
    most_recent_gasoline_price = record['dynamodb']['NewImage']['newYorkStateAverageGal']['S']
    message = f'🛡🛡🛡 Gasoline price {most_recent_gasoline_price} have fell 🛡🛡🛡'
    subject = 'A gasoline price dropped has been detected'
    send_sns(message, subject)

def send_sns(message, subject):
    client = boto3.client("sns")
    client.publish(
        TopicArn=SNS_ARN, Message=message, Subject=subject)

Lastly, we use AWS Simple Notification Service (or AWS SNS) a cloud-based web service that delivers messages. In SNS we have a publisher and a subscriber.

The publisher sends out a message to the subscriber immediately instead of storing the message.

The subscriber s an entity that receives the messages to the topics that they have subscribed to. In my case, I’m using my email to receive the notifications.

Here’s the final result when I receive the mail from SNS

Summary and where to next?

This was a really interesting project that taught me two important things I won’t forget. It taught me how permissions really work on AWS. They can be confusing sometimes. Do I need a role for this project? What policy do I need to run this action? What users, groups, and roles really are, and their differences? These and other questions were the ones I was able to answer during this project. After learning how to spin up a Lambda using the Serverless framework and reading records with DynamoDB streams, it’s my turn to keep digging more into these great technologies to continue creating more projects like this.

If you want to send me feedback, or just want to connect with me, let me know via Twitter or LinkedIn. Also, if you are curious to see the entire project, check it out on my Github. Till the next one, stay safe and keep learning.

My approach to improve application performance using Amazon Elasticache #CloudGuruChallenge

Jose Hidalgo — Fri, 18 Jun 2021 03:32:43 +0000

On June 7, 2021, A Cloud Guru released a challenge about improving the performance of an application. After a very bumpy ride, I was able to complete this challenge. One of the things that made me work on this challenge was the need to learn terraform, so I found existing building the infrastructure of this project using terraform.

Check it out! Let's connect?
Github
LinkedIn

My learnings

When I started this challenge, there were a couple of things that I didn't know about AWS and one of the reasons that made me work on this. One of them was that I thought that it was possible to access a Redis cluster from the public web, after some investigation I quickly realized that is not safe to expose my Redis to the internet. I have to say that doing the networking on AWS was challenging and is something that I will spend more time practicting now that I successfully completed this project from the ground up, creating a public VPC that allows my resources to connect to that VPC and all subsequent resources that I wanted. It took me around 4 days without sleep to set up the whole infrastructure on AWS, I cannot remember how many times I had to run: terraform destroy to start again because there were some misconfigurations on the server.

My approach to the challenge

Before I even started the challenge, I had an idea of what was terraform but did not know where to start. I saw a course on Udemy that gave me a good understanding on how to start this challenge using terraform. I was very eager to start this project and after having a good knowledge of terraform and watching the course, I moved up to create my first EC2 Instance. The things I learned on terraform are how I can reuse the same line of code called modules to create multiple resources on AWS and the way I can share variables across the code. I found this very interesting and just could stop myself from learning it.

Why I took the challenge?

At my workplace terraform is what we use to deploy our infrastructure to AWS and I want to keep leveling up on my career by expanding my knowledge and taking on challenges that put me to test.

The Project

Once I was able to set up my infrastructure on terraform and seeing I was able to connect to my EC2 and ping to my RDS ad Redis without any problem. The only thing I was missing was installing nginx on my server. I chose the amazon linux ami that use centos. I had to investigate how to install nginx on centos as it was my first-time using centos and I did not know that I had to use yum instead of apt, the good thing was that the set up was not complicated at all. After having all the set up in place, I had to make some modifications to the code to cache our query. The result was:

Having that in place, once we visit the application and because there is a timer in the sql function, the application takes some time to get the response from the server and including the time to connect to the database and return it back to the server.

As we can see on the image above, it takes around 5sec to get the results back to the server, which is a long time, if we compare it by caching the result with redis, time would be around: 0.023sec the timedelta is a huge difference:

Conclusion

I want to thank #acloudguru for this amazing challenge and I am really waiting to see more like this on the following months. I always appreciate any and all feedback.

Thanks for reading! 😀