Forem: Rajath Kumar K S

EC2 User Data for Beginners

Rajath Kumar K S — Sun, 06 Apr 2025 09:57:49 +0000

Amazon EC2 (Elastic Compute Cloud) allows you to launch virtual servers in the cloud, and one of its most powerful features is the ability to run custom setup scripts at instance startup using User Data. This guide walks you through creating an EC2 instance and configuring it to serve a basic HTML page using NGINX installed automatically through User Data.

What is EC2 User Data?

User Data is a feature in AWS EC2 that lets you pass a script to an instance at the time of its launch. This script runs as the root user the first time the instance boots. It's commonly used to:

Install software packages.
Configure the system.
Deploy applications.
Set up services (e.g., web servers, databases)

Prerequisites

An AWS account with the necessary permissions.
Access to the EC2 dashboard.
A key pair for SSH access (create one in AWS if needed)

Step-by-Step: Launching an EC2 Instance to Serve HTML with NGINX

1. Go to the EC2 Dashboard

Log in to the AWS Management Console
Navigate to EC2 under "Services"
Click Launch Instance

2. Configure Basic Settings

Name: nginx-html-server
AMI: Amazon Linux 2 (Free Tier eligible)
Instance Type: t2.micro (Free Tier eligible)
Key Pair: Select or create a key pair

3. Set Network and Security

Enable the following ports in the Security Group:
- SSH (port 22)
- HTTP (port 80)

4. Add the User Data Script

Scroll to the Advanced Detail section and paste the following script:

#!/bin/bash
yum update -y
amazon-linux-extras install nginx1 -y
systemctl enable nginx
systemctl start nginx
echo "<h1>Hello from NGINX!</h1>" > /usr/share/nginx/html/index.html

This script will:

Update the OS
Install NGINX
Start and enable the NGINX service
Replace the default welcome page with a custom HTML file

5. Launch the Instance

Click Launch Instance
Wait a few seconds for the instance to initialize

Verifying the Setup

Method 1: Browser

Copy the Public IPV4 address of the instance
Open a web browser and go to http://<your-ec2-ip>
You should see the custom HTML page served by NGINX

Method 2: SSH

Open a terminal and SSH into your EC2 instance using the key pair you created:

ssh -i <your-key-pair>.pem ec2-user@<your-ec2-ip>
sudo cat /var/log/cloud-init-output.log

This log will show you the output of the User Data script.
Check for any errors or output to confirm everything is working correctly.

Advanced Use Cases for User Data

1. Automated Deployment

User Data can be used to automate the deployment of applications.
For example, you can use it to install and configure a web application.

2. Configuration Management

User Data can be used to manage configuration files.
For example, you can use it to update the configuration of a web server.

3. Security Best Practices

User Data can be used to enforce security best practices.
For example, you can use it to install security tools and configure them.

User Data Scripts can be extended to:

Deploy a full website from a GitHub repository.
Configure SSL certificates.
Add firewall rules, monitoring, and logging.

If you are having full static website (including, html, css, js and so on), you can use the following script to install and configure NGINX:

#!/bin/bash
#!/bin/bash
yum update -y
amazon-linux-extras install nginx1 -y
yum install -y nginx git
cd /usr/share/nginx/html
rm -rf *
git clone https://github.com/your-repo/static-website.git .
systemctl enable nginx
systemctl start nginx

Summary

Using EC2 User Data and NGINX, you can automate the deployment of a static HTML site the moment your instance boots. It’s a clean and fast way to get up and running with a web server in minutes—perfect for prototyping, demos, or even hosting a simple landing page.

Whether you're automating infrastructure or deploying a portfolio site, this approach gives you flexibility and speed.

Happy deploying!

Got questions or want to explore more ways to use NGINX on EC2? Reach out to me on LinkedIn.

Read this blog on https://blog.python.rest

blog.python.rest / posts/ec2-user-data-for-beginners/

Creating a Middleware in FastAPI for Logging Request and Responses

Rajath Kumar K S — Sun, 06 Apr 2025 09:49:00 +0000

FastAPI is a modern, high-performance web framework for Python. One of its powerful features is the ability to customize behavior using middlewares. In this blog, we will walk through creating a middleware to log every request and response, along with useful metadata like the client's IP address, HTTP method, endpoint, and status codes.

Why Use Middleware for Logging?

Middleware in FastAPI is a hook that gets executed for every request and response. This makes it an ideal place to:

Log Client Details: Capture IP addresses, user agents, etc.
Monitor API Usage: Track requests and responses.
Debugging and Auditing: Maintain a log of all interactions with your application.

Setting Up FastAPI

Before we begin, ensure you have FastAPI installed. If not, install it using:

pip install fastapi[all]

Let’s create a basic FastAPI app:

from fastapi import FastAPI
app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Welcome to FastAPI!"}

Creating the Middleware

Here's how to create a middleware for logging.

1. Import Required Modules

We'll use Python's built-in logging module to log data into a file.

import logging
from fastapi import FastAPI, Request
from starlette.middleware.base import BaseHTTPMiddleware

2. Configure Logging

Set up a log file and format the logs.

logging.basicConfig(
    filename="app.log",
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

3. Define the Middleware

Create a custom middleware class that processes every request and response.

class LoggingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        # Log request details
        client_ip = request.client.host
        method = request.method
        url = request.url.path

        logger.info(f"Request: {method} {url} from {client_ip}")

        # Process the request
        response = await call_next(request)

        # Log response details
        status_code = response.status_code
        logger.info(f"Response: {method} {url} returned {status_code} to {client_ip}")

        return response

4. Add Middleware to the App

Integrate the middleware with your FastAPI app:

import logging
from fastapi import FastAPI, Request
from starlette.middleware.base import BaseHTTPMiddleware

# Configure logging
logging.basicConfig(
    filename="app.log",
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Create FastAPI app
app = FastAPI()

# Define logging middleware
class LoggingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        # Log request details
        client_ip = request.client.host
        method = request.method
        url = request.url.path

        logger.info(f"Request: {method} {url} from {client_ip}")

        # Process the request
        response = await call_next(request)

        # Log response details
        status_code = response.status_code
        logger.info(f"Response: {method} {url} returned {status_code} to {client_ip}")

        return response

# Add middleware to the app
app.add_middleware(LoggingMiddleware)

# Define a sample route
@app.get("/")
async def read_root():
    return {"message": "Welcome to FastAPI!"}

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

Testing the Middleware

1. Run the FastAPI App: Start the application by running the script:

uvicorn app:app --reload

2. Send Requests: Use tools like curl, Postman, or a browser to interact with the API. For example:

curl http://127.0.0.1:8000/
curl http://127.0.0.1:8000/items/42

3. Check the Logs: Open the app.log file to see the logged requests and responses. It will look something like this:

2024-12-04 12:05:00,001 - INFO - Request: GET / from 127.0.0.1
2024-12-04 12:05:00,002 - INFO - Response: GET / returned 200 to 127.0.0.1
2024-12-04 12:06:00,003 - INFO - Request: GET /items/42 from 127.0.0.1
2024-12-04 12:06:00,004 - INFO - Response: GET /items/42 returned 200 to 127.0.0.1

Conclusion

With this middleware, you can easily log all API requests and responses in your FastAPI application. This is incredibly useful for debugging, auditing, and monitoring the usage of your APIs. You can further customize the middleware to log headers, request bodies, or response payloads if needed.

Logging is an essential part of any production-grade application, and FastAPI’s middleware support makes it easy to implement.

blog.python.rest / posts/fastapi-middleware-logging/

Follow me on LinkedIn