Forem: Asrin

Event driven architectures using AWS with example

Asrin — Sun, 29 Jan 2023 15:29:05 +0000

Event-driven architectures are becoming increasingly popular in modern software development, and Amazon Web Services (AWS) provides several tools to implement this style of architecture. In this blog, we will discuss what event-driven architectures are, why they are useful, and how to implement them in AWS.

What is an event-driven architecture?

An event-driven architecture is a way of designing software systems in which events trigger specific actions. This means that different parts of the system can communicate with each other by sending and receiving events, rather than directly invoking each other's methods.

Why use event-driven architectures?

Event-driven architectures provide several benefits over traditional architectures:

Loose coupling: Event-driven architectures promote loose coupling between components, making it easier to change or replace parts of the system without affecting the rest of the system.
Scalability: Event-driven architectures are inherently scalable, as it's easy to add new components to respond to events without affecting existing components.
Real-time processing: Event-driven architectures allow for real-time processing of events, making it possible to respond to events as soon as they occur.

How to implement event-driven architectures in AWS?

AWS provides several tools that make it easy to implement event-driven architectures:

Amazon SNS (Simple Notification Service): SNS is a publish/subscribe messaging service that allows you to send messages to multiple recipients at once. You can use SNS to send events from one part of your system to another, and have multiple components subscribe to these events.

Amazon SQS (Simple Queue Service): SQS is a managed message queue service that provides reliable, scalable, and efficient message delivery. You can use SQS to queue events for processing, allowing you to decouple the parts of your system that produce events from the parts that process them.

AWS Lambda: Lambda is a serverless computing service that allows you to run code without having to manage servers. You can use Lambda to respond to events by triggering Lambda functions that perform specific actions in response to events.

Real world example

Here is a real-world example of an event-driven architecture using Terraform and AWS:

Suppose we have an e-commerce website that sells products. When a customer places an order, we want to send an email to the customer with a confirmation of the order, and we also want to update the inventory of the product that was ordered.

To implement this, we can use the following components:

Amazon S3: To store the Terraform code and the inventory data.

AWS Lambda: To run the code that sends the email to the customer and updates the inventory. We will use two separate Lambda functions for these tasks.

Amazon SNS: To send the events when an order is placed and when the inventory is updated.

Terraform: To automate the creation of the above components.

Here is the Terraform code for creating the SNS topic for order placement events:

resource "aws_sns_topic" "order_placed" {
  name = "order_placed"
}

Next, we create the Lambda function that sends the email to the customer:

resource "aws_lambda_function" "send_email" {
  filename = "send_email.zip"
  function_name = "send_email"
  role = "${aws_iam_role.lambda_exec.arn}"
  handler = "index.handler"
  runtime = "python3.8"
  timeout = 30
  environment = {
    variables = {
      SENDER = "${var.sender}"
      RECIPIENT = "${var.recipient}"
    }
  }
  events = [
    {
      sns = "${aws_sns_topic.order_placed.arn}"
    }
  ]
}

And finally, the Terraform code for the Lambda function that updates the inventory:

resource "aws_lambda_function" "update_inventory" {
  filename = "update_inventory.zip"
  function_name = "update_inventory"
  role = "${aws_iam_role.lambda_exec.arn}"
  handler = "index.handler"
  runtime = "python3.8"
  timeout = 30
  environment = {
    variables = {
      INVENTORY_BUCKET = "${var.inventory_bucket}"
    }
  }
  events = [
    {
      sns = "${aws_sns_topic.order_placed.arn}"
    }
  ]
}

In this example, when a customer places an order, an SNS event is sent to the order_placed topic. This event triggers both the send_email and update_inventory Lambda functions, which perform the actions of sending an email to the customer and updating the inventory, respectively.

This is a simple example of how Terraform and AWS can be used to build an event-driven architecture. By using Terraform, you can automate the creation and deployment of these components, making it easier to manage and scale your architecture as your needs change over time.

Conclusion

Event-driven architectures are a useful tool for designing modern software systems, and AWS provides several tools to make it easy to implement this style of architecture. By using tools such as SNS, SQS, and Lambda, you can build scalable, real-time systems that respond to events as soon as they occur.

This article was created with the help of AI

Save EC2 costs by using a AWS Savings plan

Asrin — Sun, 11 Sep 2022 11:11:45 +0000

Save EC2 costs by using a AWS Savings plan

This is a real-life case of how I save 38% of EC2 micro cost using EC2 Instance Savings Plan.

I have an EC2 micro running at the moment which is always running a Barbershop website. There is no plans to take down or switch infrastructure within the next year so I thought I would save some costs by pre purchasing the EC2 using EC2 Savings plan.

Calculate savings

First calculate how much you will save using savings using this AWS Savings plan Calculator

Here I calculate my costs for an EC2 micro

As you see here it will cost me 0.0072 per hour.

For a month it will cost around $5.18 (0.0072 x 24 x 30 = 5.184)

Check how much you pay currently for your EC2 in your Billing Dashboard by going to your AWS Billing Dashboard and selecting last month’s bill

As you see below I pay $8.63 per month

So I will save $3.45 per month ($8.63 — $5.18) which would be $41.40 per year. Quite decent for not doing much🤑

Configure a EC2 Savings plan

Once you buy an EC2 savings plan it will automatically be applied to the EC2’s in your AWS account. You don’t need to do anything with your server it’s a billing configuration. See for more information

Go to your AWS Billing Dashboard > Savings Plan > Purchase subscription

Configure your plan as per your EC2 calculations you did above

Term

Select — 1 or 3 years (3 years more savings)
Region — Make sure to select same region your EC2 is in!
Instance family — Select same instance type that your EC2 is

Purchase Commitment

Copy the same value you got in your EC2 calculator (you could also pay more if you like)

Payment option — select if you want to pay more upfront which would give you even more savings or leave it as no upfront.

Start Date

You can set a start date if you like but this is optional.

Double check again the region you are using and the type of EC2

Add to cart

This was my EC2 micro configuration for a year

Submit order

Click inventory and your order will be in review

Above is based on AWS August 2022 pricing

Hope this helps😁

Feel free to comment with questions or feedback✌️

Happy coding,

Az 👨🏾‍💻

Credits

Create ACM certificate with DNS validation using Terraform

Asrin — Sat, 27 Aug 2022 16:28:00 +0000

This is how I created an HTTPS AWS Certificate (ACM) and validated it with my domain in AWSRoute53 using DNS validation, all using infrastructure as code tool Terraform.

Prerequisites

Add a variable for your domain

variable "root_domain_name" {
  type    = string
  default = "helloworld.info"
}

Replace the above helloworld.info with your domain

Route53

I had an imported route 53 already like so. See terraform docs for more info

resource "aws_route53_zone" "hello_world_zone" {
  name = var.root_domain_name
}
Create an ACM Certificate
resource "aws_acm_certificate" "hello_certificate" {
  domain_name       = var.root_domain_name
  validation_method = "DNS"
  lifecycle {
    create_before_destroy = true
  }
}

This creates a AWS ACM certificate for the domain name you set as variable
Sets validation mode to DNS

Add DNS records

resource "aws_route53_record" "hello_cert_dns" {
  allow_overwrite = true
  name =  tolist(aws_acm_certificate.hello_certificate.domain_validation_options)[0].resource_record_name
  records = [tolist(aws_acm_certificate.hello_certificate.domain_validation_options)[0].resource_record_value]
  type = tolist(aws_acm_certificate.hello_certificate.domain_validation_options)[0].resource_record_type
  zone_id = aws_route53_zone.hello_world_zone.zone_id
  ttl = 60
}

This adds DNS records from the resource above and inputs them into your Route53 host zone. Similar way you would do this as if you did it manually

Validate the certificcate

resource "aws_acm_certificate_validation" "hello_cert_validate" {
  certificate_arn = aws_acm_certificate.hello_certificate.arn
  validation_record_fqdns = [aws_route53_record.hello_cert_dns.fqdn]
}

This validates your ACM certificate with your domain name

Run Terraform

terraform fmt
terraform validate
terraform plan
terraform apply

Check ACM

In AWS Console > Certificate Manager
You should have the status as issued

Hope this helps😁

Feel free to comment with questions or feedback✌️

Happy coding,

Az 👨🏾‍💻