DEV Community: Rahman Badru

Sports API Management System

Rahman Badru — Sun, 09 Feb 2025 19:48:13 +0000

Project Description

This project demonstrates building a containerized api management system for querying sports data. It uses Amazon ECS for running containers, Amazon API Gateway for exposing REST Endpoints and an external Sports API for real-time sports data. The project showcases advanced cloud computing practices, including API management, container orchestration, and secure AWS integrations.

Project Architecture

Project Setup

Clone the Repository

git clone https://github.com/ifeanyiro9/containerized-sports-api.git
cd containerized-sports-api

-Create an ECR Repository
aws ecr create-repository --repository-name sports-api --region us-east-1

Authenticate, Build, and Push Docker Image

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin <AWS_ACCOUNT_ID>.dkr.ecr.us-east-1.amazonaws.com

docker build --platform linux/amd64 -t sports-api .
docker tag sports-api:latest <AWS_ACCOUNT_ID>.dkr.ecr.us-east-1.amazonaws.com/sports-api:sports-api-latest
docker push <AWS_ACCOUNT_ID>.dkr.ecr.us-east-1.amazonaws.com/sports-api:sports-api-latest

Set Up an ECS Cluster with Fargate
- Create an ECS Cluster:
- Navigate to the ECS Console → Clusters → Create Cluster.
- Name the cluster (e.g., sports-api-cluster).
- Choose Fargate as the infrastructure type, then create the cluster.
Create a Task Definition:
Go to Task Definitions → Create New Task Definition.
- Name the task definition (e.g., sports-api-task).
- Choose Fargate as the infrastructure type.
- Add the container:
- Name: sports-api-container
- Image URI: .dkr.ecr.us-east-1.amazonaws.com/sports-api:sports-api-latest
- Container Port: 8080
- Environment Variables:
  - Key: SPORTS_API_KEY
  - Value:
- Save and create the task definition.
Deploy the Service with an Application Load Balancer (ALB):
- Go to Clusters → Select Cluster → Service → Create Service.
- Configuration:
- Capacity Provider: Fargate
- Task Definition: sports-api-task
- Service Name: sports-api-service
- Desired Tasks: 2
- Networking:
  - Create a new security group allowing TCP traffic.
  - Type: All TCP, Source: Anywhere
- Load Balancer:
  - Select Application Load Balancer (ALB).
  - ALB Configuration:
  - Create a new ALB named sports-api-alb.
  - Health Check Path: /sports
- Create the service.
Test the ALB:
- Retrieve the ALB DNS name (e.g., sports-api-alb-.us-east-1.elb.amazonaws.com).
- Verify the API is accessible by visiting http://sports-api-alb-.us-east-1.amazonaws.com/sports.
Configure API Gateway
- Create a REST API:
- Navigate to API Gateway Console → Create API → REST API.
- Name the API (e.g., Sports API Gateway).
- Set Up Integration:
- Create a resource /sports.
- Create a GET method and choose HTTP Proxy as the integration type.
- Enter the ALB DNS name followed by /sports.
- Deploy the API: -Deploy the API to a stage (e.g., prod) and note the endpoint URL.
Test the System
- Use a browser or curl to test: curl https://<api-gateway-id>.execute-api.us-east-1.amazonaws.com/prod/sports

Conclusion

This project demonstrates how to build a scalable, containerized sports data API management system using modern AWS services such as ECS with Fargate, API Gateway, and CloudWatch. By integrating these services, we achieved a reliable and secure infrastructure for hosting and managing APIs, while also adhering to best practices like containerization and least privilege IAM policies. Future enhancements like caching with ElastiCache, user-specific data storage with DynamoDB, and implementing CI/CD pipelines can further optimize the system for performance and maintainability. This documentation serves as a comprehensive guide to replicate, deploy, and extend the system, empowering developers to leverage AWS for similar use cases.

NBA DATA LAKE

Rahman Badru — Mon, 13 Jan 2025 20:26:07 +0000

Project Description

This project automates the creation of a data lake for NBA Analytics using AWS Services. It makes use of AWS S3, Glue and Athena to store and query NBA related Data

This is the third project for the Devops All Stars Challenge

Project Architecture

Project Overview

The script data-lake.py creates an Amazon Bucket to store raw data, uploads NBA Data (json format) to the Bucket and creates an Amazon glue database and table to query the data, It also configures Amazon Athena for querying data stored in the S3 bucket.

Project Setup

Get your api key from sportsdata
Create the file called data-lake.py and copy the contents of the src/data-lake.py inside
Create the env file:
```
nano .env
```
Add the following variables in the env file:

SPORTS_DATA_API_KEY="{SPORTS_DATA_API_KEY}"
NBA_ENDPOINT="https://api.sportsdata.io/v3/nba/scores/json/Players"

Install requirements from the requirements.txt:

python3 -m venv venv ## To create a virtual environment
source venv/bin/activate ## To activate virtual environment
pip install -r requirements.txt ## to install requirements

Set your bucket_name and glue_database_name in the data-lake.py file.
Run the code with python3 src/data-lake.py

Login to AWS Console and confirm:
- The S3 Bucket has been created
- The Amazon Glue Database has been created
- Run an athena query to confirm with this, Go to Amazon Athena and paste in Query Editor:

 SELECT FirstName, LastName, Position, Team
 FROM nba_players
 WHERE Position = 'PG';

You can clean up resources by runnning python3 src/delete-resources.py

Conclusion

This project demonstrates the power of AWS services in creating a robust and automated data lake for NBA analytics. By integrating Amazon S3 for data storage, AWS Glue for data cataloging, and Amazon Athena for querying, we have built a scalable and efficient pipeline for managing and analyzing NBA data. The simplicity of the setup process ensures accessibility for developers, while the automated cleanup script emphasizes resource management and cost efficiency. This project not only highlights the capabilities of cloud-based data lakes but also serves as a foundation for exploring more advanced data analytics and insights, making it an invaluable asset for sports analytics enthusiasts and professionals.

Day 2: Creating NBA Game Day Notification System using Event-Driven Architecture

Rahman Badru — Sat, 11 Jan 2025 09:44:01 +0000

Project Description

This article details building a notification system using event driven architecture that sends NBA Game day Results to your mail at specific intervals.

This is the second project for the Devops All Stars Challenge

Project Architecture

Project Requirements

The following services/tools are required for this project:

AWS Lambda
AWS EventBridge
AWS SNS (Simple Notification System)
Python

Project Workflow

Basically the project uses AWS EventBridge to run a scheduled rule at intervals that triggers the Lambda Function which contains a python script to pull game data via the Sports Data API and send to an SNS Topic which is then now sent to either your mail or sms

The Project can be found here: Gameday-Notification

This project is implemented as follows:

Create AWS SNS TOPIC

Open the AWS Management Console
GO to SNS
Click on topics, click create topic
Select Standard as topic type
Name your topic (e.g gameday-topic) and click create topic

Create a Subscription for the Topic

Click on your topic
Click create subscription
Set Protocol to email
Put your mail
Click create Subscription
Confirm the subscription from your mail

Create an SNS Publish Policy

Open the IAM service in the AWS Management Console.
Navigate to Policies → Create Policy.
Click JSON and paste the JSON policy from gd_sns_policy.json file
Replace REGION and ACCOUNT_ID with your AWS region and account ID.
Click Next: Tags (you can skip adding tags).
Click Next: Review.
Enter a name for the policy (e.g., gameday-policy).
Review and click Create Policy.

Create IAM Role for Lambda

Open the IAM service in the AWS Management Console.
Navigate to Roles -> Create Role
Click on use case drop down and click Lambda
Click Next and then attach two policies:
- The policy create earlier (gameday-policy)
- The Lambda Basic Execution Role (AWSLambdaBasicExecutionRole) (an AWS managed policy).
CLick Next, skip tags and create the role

Create Lambda Function

Open the AWS Management Console and navigate to the Lambda service.
Click Create Function.
Select Author from Scratch.
Enter a function name (e.g., gameday-function).
Choose Python 3.x as the runtime.
Assign the IAM role created earlier (gameday-role) to the function.
Under the Function Code section:
- Copy the content of the src/gd_notifications.py file from the repository.
- Paste it into the inline code editor.
Under the Environment Variables section, add the following:
- NBA_API_KEY: your NBA API key.
- SNS_TOPIC_ARN: the ARN of the SNS topic created earlier.
Click Create Function

Set up EventBridge Schedule to trigger Lambda

Navigate to the Eventbridge service in the AWS Management Console.
Go to Rules → Create Rule.
Select Event Source: Schedule.
Set the cron schedule for when you want updates (e.g., hourly).
Under Targets, select the Lambda function (gameday-function) and save the rule.

Test the System

Open Lambda function and click on the function you created
click on test and name the event
Test the function
Verify you get a mail confirming it was successful

Conclusion

This project demonstrates how to build a notification system using event-driven architecture on AWS. By leveraging AWS Lambda, EventBridge, and SNS, you can create a reliable and efficient system to receive NBA Game Day updates via email or SMS. This setup is a great example of automating tasks and building scalable systems using cloud services.

Day 1: Setting up the AWS Weather Dashboard Application

Rahman Badru — Thu, 09 Jan 2025 21:19:37 +0000

Background

This project is a part of the 30 Days All Star Devops Challenge that aims to increase proficiency in Devops through a series of hands-on projects and documentation.

Project Description

This project makes use of Python and AWS Services (S3) to retrieve weather data from OpenWeatherAPI and stores the results in a json format in an S3 Bucket.

Tools Used:

Python: Language used to set up the Weather Dashboard
AWS S3 ( Simple Storage Service): AWS Storage Solution
OpenWeather API Key
Boto3 : AWS SDK used by python to interact with the S3 Bucket
requests: Python library used to send requests and fetch data

Environment Setup

Before implementing the weather dashboard, here are a few things needed to set up your environment.

AWS Account and AWS CLI: You need an AWS Account where your bucket will be created and the AWS CLI to set up credentials to interact with AWS
Python: Make sure Python 3.x is installed on your system as well as pip, It will be needed to install libraries
OpenWeather API Key: Get the OpenWeather API Key by signing up to this page OpenWeather

Architecture Diagram

Project Workflow

This project uses a python script that fetches weather data from openweather via its API Key and then sends/stores it to a S3 bucket in JSON Format

Here are some excerpts of the code:

class WeatherDashboard:
def __init__(self):
    self.api_key = os.getenv('OPENWEATHER_API_KEY') # Get the OpenWeather API key from environment variables
    self.bucket_name = os.getenv('AWS_BUCKET_NAME') # Get the AWS S3 bucket name from environment variables
    self.s3_client = boto3.client('s3') # Create an S3 client for interacting with AWS S3

This sets up the API key, bucket name, and S3 client when you create an instance of the WeatherDashboard class.

def fetch_weather(self, city):
    base_url = "http://api.openweathermap.org/data/2.5/weather"  # The API endpoint for weather data
    params = {
        "q": city,                        # The city name to fetch weather for
        "appid": self.api_key,            # The API key for authentication
        "units": "imperial"               # Use imperial units (Fahrenheit)
    }

    try:
        response = requests.get(base_url, params=params)  # Make a GET request to the API
        response.raise_for_status()                       # Raise an error if the response indicates failure
        return response.json()                            # Return the weather data as JSON
    except requests.exceptions.RequestException as e:
        print(f"Error fetching weather data: {e}")  # Print error if the request fails
        return None

This section gets weather information like temperature and conditions for a given city

def save_to_s3(self, weather_data, city):
    if not weather_data:  # If no data is passed, return False (skip saving)
        return False

    timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')  # Create a timestamp (e.g., 20250107-153045)
    file_name = f"weather-data/{city}-{timestamp}.json"    # Define the file path and name

    try:
        weather_data['timestamp'] = timestamp  # Add a timestamp to the weather data
        self.s3_client.put_object(             # Save the data to S3
            Bucket=self.bucket_name,           # The S3 bucket name
            Key=file_name,                     # The file path in the bucket
            Body=json.dumps(weather_data),     # Convert data to JSON format for saving
            ContentType='application/json'     # Specify the file type as JSON
        )
        print(f"Successfully saved data for {city} to S3")  # Confirm success
        return True
    except Exception as e:
        print(f"Error saving to S3: {e}")  # Print error if saving fails
        return False

This section saves it in s3 bucket

To run the project on your machine, follow these steps:

Clone the repository from here: Github Repo
Follow the instructions in the README here: README.md

When the project has been run, you should get the following output

Conclusion

This project successfully demonstrates how to build a simple yet functional weather dashboard application by integrating Python, OpenWeatherAPI, and AWS S3. Through this project, we explored retrieving real-time weather data using APIs, processing it in Python, and securely storing the results in an S3 bucket in JSON format. It highlights practical use cases of Python libraries like boto3 and requests, emphasizing the importance of cloud storage solutions in managing and persisting data. This project is an excellent starting point for developers looking to enhance their skills in API integration, cloud computing, and DevOps practices.

Enhance Your Web Protection: AWS WAF Essentials

Rahman Badru — Mon, 15 Apr 2024 09:46:56 +0000

What is the AWS WAF?

The AWS WAF which stands for Web Application Firewall is a tool that lets you monitor requests to your web application resources. It protects some of the following AWS Resources like:

Amazon Cloudfront Distribution
Application Load Balancer
Amazon API Gateway REST API and a couple of other resources.

What does the AWS WAF do?

It basically lets you control access to your content, Based on whatever conditions you specify e.g the IP addresses the requests come from, the path being requested or the location the requests originate from , the service associated with whichever resource is being protected either gives the right response, or a forbidden permission response ( also known as the 403 error) or a custom response configured by the user.

How does the AWS WAF work?

The WAF works to control how your protected resources respond to web requests and it does that using a Web ACL (Access Control List) and associating it with the resources to be secured. The resources then forward any incoming requests to the ACL for inspection.

With the web access control list,you define rules for traffic patterns which you look for in those requests,and then set the action to be taken on requests that match the patterns, which can include:

Allow the requests to go to the protected resource for processing and response.
Block the requests.
Run CAPTCHA or challenge checks against requests to verify human users

Components of the WAF

These are some of the components that make up the AWS WAF

Web ACL: You use this to protect your AWS resources via rules, The rules help define the criteria for the requests coming in and also the action to take on requests that match the rules, You can set default actions on matched requests as listed above. As an example, you can set a rule to block all requests coming from a specific IP address.
Rules: These are the building blocks of the Web ACL and they determine what actions are to be taken on requests.
Rule Groups: A rule group is a reusable set of rules that you can add to a web ACL.

Configuring the AWS WAF (Walkthrough)

To show the capabilities of the AWS Web Application Firewall, we will create an EC2 Instance running Wordpress, place it behind an Application Load Balancer and associate a WAF Web ACL to it.

We will then explore rules we can create , as well as set up logging for the WAF.

Step 1 - Creating the EC2 Instance.

First we create the EC2 Instance , using a wordpress image gotten from this link: https://bitnami.com/stack/wordpress/cloud/aws/amis

Copy the image id for the region you want to deploy the instance in.

Click on launch instance.

Give the instance , the name wordpress .

Under Application and OS Images, Paste the image ID you copied and search for it under Community Images.

Select the Image

Leave the instance type as default (t2.micro) which is free tier

Set the key pair login to "Proceed without a keypair" as we don't need access to the instance.

Under Network settings, click edit

Make sure the default VPC is selected and ensure auto assign public IP is enabled.

Create a new security group named wordpress-waf and change the security group rule 1 to HTTP.

Leave all other settings as default and launch the instance.

Once the instance has been created, copy the public ip and navigate to it in your browser.

You should see the wordpress default page.

Step 2 - Creating a target group.

Go back to the EC2 Console: EC2 Console

Go to target groups and click on create target group.

Choose the target type as instances.

Set the target group name to be wordpress

Leave everything else as default and click Next.

Select the instance created previously and select include as pending below.

Click on create target group.

Step 3 - Creating an Application Load Balancer.

On the EC2 Console Page , click on load balancers and then create load balancer.

Select the Application Load Balancer.

Set the Load Balancer name to wordpress-lb

Make sure the VPC is default and select all subnets under Network mapping.

Under Security Groups, select the wordpress-waf group we created

Under Listeners and Routing , change the action for HTTP to forward to the wordpress target group we created earlier.

Leave all other settings and create the load Balancer.

Once the ALB ( Application Load Balancer ) is created , Paste the DNS Name in the Browser, you should see the same wordpress default page as earlier.

Step 4 - Creating an s3 Bucket for WAF Logs.

Head to the S3 Console: S3 Console

Go to Buckets and click create bucket.

S3 buckets for aws waf logs must begin with aws-waf-logs- , so name your bucket with that prefix.

Make sure the bucket is in the same region as your EC2 Instance.

Leave all other settings as default and create the bucket.

Step 5 - Setting up the WAF.

Go over to the WAF Console, which can be found here: https://us-east-1.console.aws.amazon.com/wafv2/home?region=us-east-1

Ensure that the region is the same as the region your instance is in, in my case, its the us-east-1 region.

First, we would create an IP Set, which is basically a group of IP's ( which is used commonly for IP addresses you want to allow). IP Sets can contain up to 10,000 CIDR ranges, which makes allowing or blocking large numbers of networks very easy.

Check your IP address using this link:

https://checkip.amazonaws.com/ and copy your IP Address.

Go to IP Sets and create IP Set.

Set the IP Set name to home-ip

In the IP Addresses box, add the IP you copied with the /32. e.g 172.35.40.78/32.

Create the IP Set.

Go to Regex Pattern Sets and click on create regex pattern set.

Set the regex pattern name to no-wp-files

In the Regular expressions box, enter:



(wp\-login\.php)$
(.*wp\-config.*)
(xmlrpc\.php)

Click on create regex pattern set.

Go to Web ACL and click on create Web ACL

Under Resource Type, click Regional Resources.

Set the Name to wordpress-acl.

Under Associated AWS Resources, click Add AWS Resources.

Under AWS Resources, click on Application Load Balancer and select the ALB we created earlier.

Click on next.

Under Rules, click on Add Rules, and then Add Managed rule groups.

Expand AWS Managed Rule Groups and you will see a list of WAF rule groups that are supplied and maintained by AWS.

Under the Free Rule Groups, Select the following.

Core rule set
PHP application
SQL database
WordPress application

Each rule group has a description showing what kind of attacks the rule group helps protect against.

Given that our infrastructure is centered around a WordPress application, it's essential to prioritize the WordPress rules for enhanced protection. Additionally, since WordPress is PHP-based, integrating PHP application rules is crucial. As our WordPress database relies on MySQL, implementing the SQL database rule set becomes imperative to safeguard against potential SQL Injection attacks, among other threats.

The “Core rule set” contains the most rules, and protects against common attack methods provided by the open source OWASP organisation

Click on Add rules.

Note: each rule group has a “capacity” value. Each Web ACL has a maximum capacity of 1500 “WebACL Capacity Units” (WCUs), and each rule we add uses up some of those units. E.g The SQL rule has a capacity value of 200.

Under the Default web ACL action for requests that don't match any rules , set it to Allow, this is because we only want to block traffic matching any of our rules.

Click on Next.

You can also set the rule priority for the rules selected earlier. Web ACL rules are executed top to bottom, so the first rule is executed first and so on.

Click Next and ensure that Request sampling options is set to enabled.

Create your Web ACL

Once the WAF has been created, click on it and under Logging and metrics, click Enable

Then click on s3 bucket as logging destination and select the bucket we created earlier.

Then save.

Step 6 - Testing the WAF.

Open the ALB URL that we visited earlier.

We should be able to view the wordpress page, and even the blog and admin page (/sample-page/ and /wp-admin).

If we try a simple SQL Injection Attack like : /wp-login.php?user=1+ORDER+BY+10 , the WAF should stop us with a code 403 ( permission denied).

Once verified that the WAF rules are working as expected.

Go back to the WAF Console, click on your WAF and navigate to the Sampled requests.

If you search for your IP Address, you should see the requests you made, the actions applied on those requests (ALLOW/BLOCK) and the rule that cause any block action.

Step 7 - Adding Custom Rules to your WAF Web ACL.

We don’t want our WordPress login page or XML-RPC page being accessed by anyone, so we’re going to use our regex pattern we created earlier to block any requests to /wp-login.php or /xmlrpc.php

Go to your WAF console: https://us-east-1.console.aws.amazon.com/wafv2/home?region=us-east-1

Click on your wordpress web acl.

Navigate to rules. Then click on Add rules, and add my own rule and rule groups

Leave the rule type as Rule Builder and name it no-wp-files.

Leave the type as a regular based rule.

Under the block If a request matches the statement, set the inspection option to URI Path

Set Match Type to “Matches pattern from regex pattern set”

Set Regex pattern set to the pattern set we created earlier (no-wp-files).

Set Text transformation to “Lowercase” ,this changes everything in our inspection option which is the URI path to lowercase. e.g /wp-login.php and /WP-LOGIN.PHP will be seen by the WAF as /wp-login.php

Under Action, Select Block

On the next page, we need to move our new rule to the top of the priority list. Remember that rules in Web ACL are executed in order of top to bottom.

Select your new rule, and keep clicking Move up until it’s at the top of the list.

Then save

Now if we try accessing either the /wp-login.php,/wp-admin or /xmlrpc.php. We will get a 403 forbidden message.

If we check the sampled requests of the AWS WAF console, we would see our IP and the path requested, with the action shown as BLOCK.

We can also add many other custom rules such as:

Allowing our home ip access to the application, since it is a trusted ip
Allowing requests coming from a particular country, while blocking all other requests.

Step 8 - Viewing our WAF Logs.

We can view our WAF Logs by going to the bucket we created in the S3 Console: S3 Console.

Go to buckets and click on our waf logs bucket.

The directory structure will be:

/AWSLogs/[ACCOUNT ID]/WAFLogs/[REGION]/[WEB ACL]/[YEAR]/[MONTH]/[DAY]/[HOUR]/[5 MINUTE BLOCK]/[LOGS]

You can download the logs (which is in the .log format) and view it using the json pretty print website: https://jsonformatter.org/json-pretty-print, as the json file might be difficult to read.

An example of a log can be this:



{
  "timestamp": 1713169621018,
  "formatVersion": 1,
  "webaclId": "arn:aws:wafv2:us-east-1:567635759120:regional/webacl/wordpress-acl/24ce438c-a4b9-467f-8b4c-ba5ab8d56db3",
  "terminatingRuleId": "no-wp-files",
  "terminatingRuleType": "REGULAR",
  "action": "BLOCK",
  "terminatingRuleMatchDetails": [
    {
      "conditionType": "REGEX",
      "location": "URI",
      "matchedData": null,
      "matchedFieldName": ""
    }
  ],
  "httpSourceName": "ALB",
  "httpSourceId": "567635759120-app/wordpress-lb/3630369d4fc6a356",
  "ruleGroupList": [
    {
      "ruleGroupId": "AWS#AWSManagedRulesPHPRuleSet",
      "terminatingRule": null,
      "nonTerminatingMatchingRules": [],
      "excludedRules": null,
      "customerConfig": null
    }
  ],
  "rateBasedRuleList": [],
  "nonTerminatingMatchingRules": [],
  "requestHeadersInserted": null,
  "responseCodeSent": null,
  "httpRequest": {
    "clientIp": "154.118.22.58",
    "country": "NG",
    "headers": [
      {
        "name": "Host",
        "value": "wordpress-lb-1743095222.us-east-1.elb.amazonaws.com"
      },
      {
        "name": "Connection",
        "value": "keep-alive"
      },
      {
        "name": "Upgrade-Insecure-Requests",
        "value": "1"
      },
      {
        "name": "User-Agent",
        "value": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
      },
      {
        "name": "Accept",
        "value": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7"
      },
      {
        "name": "Accept-Encoding",
        "value": "gzip, deflate"
      },
      {
        "name": "Accept-Language",
        "value": "en-GB,en-US;q=0.9,en;q=0.8"
      }
    ],
    "uri": "/xmlrpc.php",
    "args": "",
    "httpVersion": "HTTP/1.1",
    "httpMethod": "GET",
    "requestId": "1-661ce4d5-403eac0b43ee412a6810f599"
  }
}

Here in this log file,you see the ACTION set to block and the terminating rule ID is the no-wp-files custom rule we created earlier.

You can also see all of our request headers are there, as well as the URI, query strings, etc. This can be removed if you prefer.

Step 9- Clean Up.

Ensure all the resources created during this walkthrough are deleted. These include :

Web ACL
IP Sets
Regex Pattern Sets
S3 Bucket
EC2 Instance
Target Groups
Load Balancer
Security Groups

I trust that this article has effectively demonstrated the capabilities of AWS WAF and provided you with a deeper understanding of its functionality and implementation.

References

AWS WAF Documentation
Andrew Cantrill's WAF Demo Guide

DEV Community: Rahman Badru

Sports API Management System

Project Description

Project Architecture

Project Setup

Conclusion

NBA DATA LAKE

Project Description

Project Architecture

Project Overview

Project Setup

Create the env file:

Conclusion

Day 2: Creating NBA Game Day Notification System using Event-Driven Architecture

Project Description

Project Architecture

Project Requirements

Project Workflow

Create AWS SNS TOPIC

Create a Subscription for the Topic

Create an SNS Publish Policy

Create IAM Role for Lambda

Create Lambda Function

Set up EventBridge Schedule to trigger Lambda

Test the System

Conclusion

Day 1: Setting up the AWS Weather Dashboard Application

Background

Project Description

Tools Used:

Environment Setup

Architecture Diagram

Project Workflow

Conclusion

Enhance Your Web Protection: AWS WAF Essentials

What is the AWS WAF?

What does the AWS WAF do?

How does the AWS WAF work?

Components of the WAF

Configuring the AWS WAF (Walkthrough)

Step 1 - Creating the EC2 Instance.

Step 2 - Creating a target group.

Step 3 - Creating an Application Load Balancer.

Step 4 - Creating an s3 Bucket for WAF Logs.

Step 5 - Setting up the WAF.

Step 6 - Testing the WAF.

Step 7 - Adding Custom Rules to your WAF Web ACL.

Step 8 - Viewing our WAF Logs.

Step 9- Clean Up.

References