DEV Community: Naami Ahmed

How to Prevent Unnecessary Charges on AWS: Free Billing Alerts for Beginners

Naami Ahmed — Fri, 14 Nov 2025 15:15:34 +0000

Introduction

AWS is one of the most popular cloud platforms, but beginners often get surprised by unexpected charges. Luckily, AWS provides free tools to monitor your spending and prevent unnecessary costs. In this article, we will guide you step by step to set up free billing alerts, understand usage limits, and stay safe while learning AWS.

Target Audience: Beginners who want to avoid surprises in their AWS billing.

Step 1: Enable AWS Billing Alerts (Free)

Before creating alerts, you must enable billing alerts in your account. This allows AWS to track your usage and send notifications if you approach your free tier or budget limits.

Steps:

Log in to AWS Management Console.
Go to Billing & Cost Management → Billing Preferences.

Tick:

Receive Free Tier Usage Alerts – This sends alerts when you are nearing the free tier limits, so you can avoid accidental charges.

Click Save to activate this alert.

Step 2: Create an AWS Budget Alert (Free)

The AWS Budget feature allows you to define a spending limit and get email notifications when your usage reaches specific thresholds. This gives beginners more control and peace of mind while learning.

Steps:

Go to Billing → Budgets → Create Budget.
Choose Cost Budget and set your monthly limit (for example, $2 USD). This is the maximum you are willing to spend in a month.
Add alert thresholds to receive notifications at 50%, 80%, and 100% of your budget. Each alert warns you before reaching the full limit.
Add your email address for notifications and click Save.

Tip: Always use email notifications, as SMS alerts may incur small charges.

Step 3: Enable Cost Explorer (Optional, Free)

AWS Cost Explorer helps you visualize your spending over time. By tracking daily usage and costs, you can better understand which services may contribute to charges and make adjustments before they become an issue.

Steps:

Go to Billing → Cost Explorer.
Click Enable to activate the tool. Once enabled, you can view your usage in graphs and tables.

Safe to use (Free):

IAM (users & permissions) – Manage access without creating cost.

Billing dashboard & CloudWatch billing alerts – Free tools to monitor your usage.

AWS Budgets & Cost Explorer – Tools to track spending and visualize data for free.

Additional Tips to Stay Safe

Regularly check Free Tier usage: Even small services can exceed limits if forgotten. Monitoring usage helps avoid surprises.
Use tags to track resources: Tags make it easy to identify and manage resources, especially if you try multiple services at once.
Delete resources you are not using: Unused resources, like instances or storage, can lead to unexpected charges.
Monitor daily billing with Cost Explorer: Keeping an eye on daily costs helps you react before reaching your budget.
Set low budgets initially: Beginners can start with $1–$2 per month to test alerts and get familiar with AWS billing.

Conclusion

Setting up AWS billing alerts is simple, free, and essential for beginners. By combining budget alerts, free tier alerts, and monitoring tools, you can confidently explore AWS without worrying about unexpected charges. Adding screenshots and visuals in your article or video will make these steps even clearer and more engaging for beginners.

🎮 Building a Mini Tic-Tac-Toe Game Using Amazon Q Developer and Python

Naami Ahmed — Mon, 10 Nov 2025 14:51:56 +0000

Introduction

Artificial Intelligence (AI) is becoming more accessible for developers to integrate into their projects. Amazon Q Developer is a powerful AI coding assistant from AWS that helps developers generate, debug, and improve code directly inside their IDE.

In this article, I’ll walk you through a practical example: creating a mini Tic-Tac-Toe game in Python using Amazon Q Developer. This will give you hands-on experience with AI-assisted coding while exploring how AWS’s developer tools work.

🧠 What is Amazon Q Developer?

Amazon Q Developer is an AI-powered coding assistant integrated into IDEs like VS Code.
It helps developers by:

Generating or explaining code.
Suggesting fixes or optimizations.
Improving documentation and refactoring logic.

It’s part of AWS’s effort to make development more intelligent and cloud-ready.
You can also use Amazon Q Business (for enterprise workflows) or Q Developer (for coding).

Free Usage: The Developer (Free) tier gives you full AI assistance inside VS Code without any extra cost — perfect for personal learning or experiments.

⚙️ Step 1: Environment Setup

Install Python 3.10+ on your computer.
Install VS Code.
Add the Amazon Q Developer extension in VS Code.
Sign in using your AWS Builder ID.
Create a project folder:

TicTacToe-Q

Create a file named:

main.py

💻 Step 2: Writing a Simple Tic-Tac-Toe Game

Start with a simple console-based Python version (If you want, you can start the code generation using Amazon Q):

import tkinter as tk
import random

# --- Basic Setup ---
root = tk.Tk()
root.title("Tic Tac Toe - Amazon Q AI")
root.configure(bg='#2c3e50')
root.geometry('400x500')

# Game variables
board = [""] * 9
player = "X"
game_active = True

# --- AI Functions ---
def ai_move():
    # Try to win
    for i in range(9):
        if board[i] == "":
            board[i] = "O"
            if check_winner() == "O":
                return i
            board[i] = ""

    # Block player from winning
    for i in range(9):
        if board[i] == "":
            board[i] = "X"
            if check_winner() == "X":
                board[i] = ""
                return i
            board[i] = ""

    # Take center if available
    if board[4] == "":
        return 4

    # Take corners
    corners = [0, 2, 6, 8]
    available_corners = [i for i in corners if board[i] == ""]
    if available_corners:
        return random.choice(available_corners)

    # Take any available spot
    available = [i for i in range(9) if board[i] == ""]
    return random.choice(available) if available else None

# --- Functions ---
def check_winner():
    wins = [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]
    for a,b,c in wins:
        if board[a] == board[b] == board[c] != "":
            return board[a]
    if "" not in board:
        return "Draw"
    return None

def show_winner_overlay(winner):
    if winner == "Draw":
        winner_overlay.config(text="🤝 It's a Draw!", fg='#95a5a6')
    else:
        symbol = "🎉" if winner == "X" else "🤖"
        player_name = "You" if winner == "X" else "AI"
        color = '#e74c3c' if winner == 'X' else '#f39c12'
        winner_overlay.config(text=f"{symbol} {player_name} ({winner}) Wins!", fg=color)
    winner_overlay.place(relx=0.5, rely=0.4, anchor='center')
    restart_overlay_btn.place(relx=0.5, rely=0.55, anchor='center')
    reset_button.grid_remove()

def reset_game():
    global board, player, game_active
    board = [""] * 9
    player = "X"
    game_active = True
    winner_overlay.place_forget()
    restart_overlay_btn.place_forget()
    reset_button.grid(row=5, column=0, columnspan=3, pady=15)
    for btn in buttons:
        btn.config(text="", bg='#34495e', fg='white')
    status_label.config(text="Your Turn (X)", fg='#3498db')

def update_button_color(btn, symbol):
    if symbol == "X":
        btn.config(fg='#e74c3c', bg='#ecf0f1')
    else:
        btn.config(fg='#f39c12', bg='#ecf0f1')

def click_button(i):
    global player, game_active
    if board[i] == "" and game_active and player == "X":
        board[i] = player
        buttons[i].config(text=player)
        update_button_color(buttons[i], player)

        winner = check_winner()
        if winner:
            game_active = False
            show_winner_overlay(winner)
            return

        # AI turn
        player = "O"
        status_label.config(text="AI is thinking...", fg='#f39c12')
        root.after(500, ai_turn)

def ai_turn():
    global player, game_active
    if game_active:
        move = ai_move()
        if move is not None:
            board[move] = "O"
            buttons[move].config(text="O")
            update_button_color(buttons[move], "O")

            winner = check_winner()
            if winner:
                game_active = False
                show_winner_overlay(winner)
                return

            player = "X"
            status_label.config(text="Your Turn (X)", fg='#3498db')

# --- Create UI ---
title_label = tk.Label(root, text="🎮 Tic Tac Toe AI", font=("Arial", 18, "bold"), 
                      bg='#2c3e50', fg='#ecf0f1')
title_label.grid(row=0, column=0, columnspan=3, pady=10)

buttons = []
for i in range(9):
    btn = tk.Button(root, text="", width=6, height=3, font=("Arial", 24, "bold"),
                    bg='#34495e', fg='white', relief='raised', bd=3,
                    command=lambda i=i: click_button(i))
    btn.grid(row=i//3+1, column=i%3, padx=5, pady=5)
    buttons.append(btn)

status_label = tk.Label(root, text="Your Turn (X)", font=("Arial", 16), 
                       bg='#2c3e50', fg='#3498db')
status_label.grid(row=4, column=0, columnspan=3, pady=10)

reset_button = tk.Button(root, text="🔄 New Game", font=("Arial", 12, "bold"),
                        bg='#27ae60', fg='white', relief='raised', bd=2,
                        command=reset_game)
reset_button.grid(row=5, column=0, columnspan=3, pady=15)

# Winner overlay (hidden initially)
winner_overlay = tk.Label(root, text="", font=("Arial", 20, "bold"),
                         bg='#2c3e50', relief='solid', bd=2, padx=20, pady=10)

# Restart button for winner overlay (hidden initially)
restart_overlay_btn = tk.Button(root, text="🔄 Play Again", font=("Arial", 12, "bold"),
                               bg='#e67e22', fg='white', relief='raised', bd=2,
                               command=reset_game)

root.mainloop()

Run this code (click Run ▶️ at the top or press F5) once to make sure it works fine.

💻 Step 4: Installing Amazon Q in VS Code

Before starting your project, you need the Amazon Q Developer extension in VS Code:

Open VS Code.
Go to the Extensions panel (click the square icon on the left sidebar or press Ctrl + Shift + X). 3.In the search bar, type:

Amazon Q Developer

Click Install on the extension.
After installation, sign in using your AWS Builder ID (or create one if you don’t have it). 6.You’ll now see the Amazon Q panel on the side of VS Code. This is where you can:

Chat with Amazon Q.
Generate or improve code.
Ask for explanations of your Python scripts.

✅ Now your VS Code is ready to use Amazon Q for interactive AI coding.

🤖 Step 4: Using Amazon Q to Improve the Game

Now that your base version works, let’s make it more advanced using Amazon Q.

Inside VS Code:
Open Amazon Q Chat (Ctrl + Shift + P → Amazon Q: Chat).
Ask questions like:

“Convert this Tic-Tac-Toe game to GUI using Tkinter.”
“Add AI logic so the computer can play automatically.”
“Refactor this into object-oriented Python code.”

Amazon Q will generate improved snippets or even a full new version of your code.
You can directly replace or merge suggestions.

🚀 Conclusion

Amazon Q Developer is a promising tool from AWS that brings AI into your coding workflow.
While it may seem a little complex to set up, it offers great educational value — especially for those who plan to grow their skills in the AWS ecosystem.

Starting with a small project like Tic-Tac-Toe is a fun and practical way to understand how AI-assisted coding can help you improve your logic, refactor code, and experiment confidently.

Keep exploring — and maybe your next project could integrate AWS Lambda or DynamoDB with your game! ☁️🎮

Thank You for Reading 🙌🙌🙌

[Boost]

Naami Ahmed — Thu, 02 Oct 2025 02:34:28 +0000

Become an AWS Cloud Club Captain – Sri Lanka 2025

Naami Ahmed ・ Oct 1

#webdev #programming #productivity #beginners

Become an AWS Cloud Club Captain – Sri Lanka 2025

Naami Ahmed — Wed, 01 Oct 2025 13:33:53 +0000

Cloud is shaping the future of technology, and students around the world are stepping up to lead this change. The AWS Cloud Club Captain program is an initiative by Amazon Web Services that empowers students to build and grow their own tech communities. As a Captain, you don’t just learn cloud — you share knowledge, organize events, and become the face of AWS on your campus.

For students in Sri Lanka, this is a chance to stand out as a leader in the growing cloud ecosystem and open doors to new opportunities.

📅 Application Deadline

The application deadline has been extended to October 6th, 2025. If you are passionate about technology, leadership, and community building, now is the best time to apply.

Who Can Apply?

To be eligible for the program, you must be:

A university or institute student who is currently enrolled.
Someone who will graduate after October 2026.
Interested in leadership, community building, and cloud technologies.

The program is designed for students who want to go beyond personal learning and create a bigger impact by supporting peers and driving cloud adoption on campus.

Why Become a Cloud Club Captain?

Being a Captain is more than just a title. It’s an opportunity to grow your technical and leadership skills while connecting with a global network of students and professionals.

Some of the key benefits include:

AWS Certification Vouchers: Captains receive exam vouchers to pursue industry-recognized AWS certifications.
AWS Credits: Hands-on learning is supported through credits to explore AWS services.
Recognition Badges: Captains can earn Bronze, Silver, Gold, and Platinum badges as they progress and achieve milestones.
Networking Opportunities: Gain access to AWS experts, professionals, and other captains worldwide.
Leadership Development: From organizing workshops to leading hackathons, you will build skills that strengthen both your resume and confidence.

The value of this program is not just in the resources, but in the real-world leadership experience and the strong community connections you build along the way.

Application Process

The application is designed to help AWS understand your passion, leadership potential, and vision. It consists of three main parts:

Written Application
You will be asked to answer questions about your background, leadership journey, and ideas for growing a student cloud community. This is your chance to share your story and vision.
Video Submission
A short (2–3 minute) video introducing yourself and explaining why you want to become a Cloud Club Captain. Keep it natural, authentic, and enthusiastic.
Faculty Support Letter
A recommendation letter from a faculty member is required to confirm your suitability and support your application.

After preparing these, you can submit them directly through the AWS Cloud Club Captain application portal.

Why This Matters for Sri Lanka

Sri Lanka’s tech landscape is growing rapidly, and cloud skills are in high demand. Programs like AWS Cloud Clubs give students the platform to gain skills, share knowledge, and contribute to the country’s future workforce.

Captains play a vital role in this ecosystem — bringing together students, organizing events, and creating opportunities that go beyond the classroom. By stepping into this role, you are not only helping yourself, but also shaping the next generation of cloud leaders in Sri Lanka.

Final Thoughts

If you’re a student graduating after October 2026, this is your opportunity to take the lead and make an impact. The AWS Cloud Club Captain program combines learning, leadership, and community in one platform.

📅 Deadline: October 6th, 2025
📹 Watch my application video here: https://youtu.be/VbGNlV9Mqog?si=Zfgv627rbSNIq6qy
🔗 Apply here: https://pulse.aws/application/TAWKU3CJ?p=0

Let’s build the future of cloud in Sri Lanka, together. 🚀

How to Host a Static Website on AWS S3 — Complete Step-by-Step Guide

Naami Ahmed — Tue, 01 Jul 2025 13:30:58 +0000

Hosting a website no longer requires a complex server setup or expensive infrastructure. If you’re looking for a quick, reliable, and low-cost way to publish your HTML/CSS/JavaScript site, then Amazon S3 is your best friend. In this article, I’ll guide you through the complete process of hosting a static website on AWS S3, and we’ll also include a live demo at each key step to make things easy to follow.

** What is Amazon S3?**
Amazon Simple Storage Service (S3) is a highly scalable object storage service offered by AWS. It allows you to store and retrieve any amount of data from anywhere on the internet. From backups and application data to static websites and image hosting, S3 is a powerful tool used by developers and businesses worldwide.

With built-in redundancy, versioning, encryption, and fine-grained access control, S3 is more than just a file storage system — it’s an enterprise-level solution. For this article, we’ll focus on one of its most practical features: hosting static websites.

🌍** Why Use S3 to Host a Website?**
There are many reasons why S3 is perfect for hosting static sites:

No server management: You don’t need to worry about Apache, Nginx, or scaling.
Highly reliable and durable: 99.999999999% durability ensures your files are safe.
Cheap or even free (with the AWS Free Tier).
Fast performance, especially when combined with AWS CloudFront (CDN).
Perfect for portfolios, landing pages, resumes, and documentation websites.

🛠️ Prerequisites
Before you begin, make sure you have the following:

A working AWS account (the free tier is sufficient).
A static website ready to upload. This could be your personal portfolio or a sample HTML/CSS project.
IAM (Identity and Access Management) user credentials — avoid using the root account for safety.
🧭 Overview: 5 Key Steps to Host a Website on S3
Here’s what we’ll be doing in this tutorial:

Create an S3 bucket
Upload the website files
Enable public access
Set a bucket policy
Enable static website hosting Let’s dive in.

📦 Step 1: Create an S3 Bucket
After logging in to your AWS Management Console, search for S3 using the top search bar. Click on the S3 service and then click the “Create bucket” button.

You’ll be prompted to enter a unique bucket name (bucket names must be globally unique). Choose your preferred AWS region (like Asia Pacific — Mumbai) and leave most settings at their default.

Click Create bucket, and you’re done! You’ve just created a cloud storage container that will hold your website files.

📁 Step 2: Upload Website Files
Next, open your newly created bucket and click on the “Upload” button. You’ll need to upload your static website files — typically index.html, along with folders for CSS, images, and JavaScript.

It’s important to keep your folder structure consistent so your site behaves the same after upload. Start by uploading the root-level files (like index.html), then add folders like /css, /img, or /js.

Once all files and folders are selected, click Upload and wait until the upload succeeds.

🔓 Step 3: Enable Public Access
By default, all files and buckets in S3 are private. To allow users to access your website, you must enable public access to the bucket.

To do this, go to the Permissions tab of your bucket. Click Edit under “Block public access,” uncheck “Block all public access,” and then confirm your change. AWS may prompt you to type a confirmation statement to avoid accidental misconfiguration.

Once this is saved, your bucket is now publicly accessible — but we still need to set permissions for each file. That’s where the next step comes in.

📝 Step 4: Set a Bucket Policy
Now let’s configure a bucket policy — a JSON-based configuration that defines who can access your bucket and what actions they can perform.

In the Permissions tab, scroll down to Bucket policy, click Edit, and paste this policy:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicReadGetObject",
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::your-bucket-name/*"
    }
  ]
}

Make sure to replace "your-bucket-name" with your actual bucket name. This policy gives the public read-only access to all files in your bucket — exactly what we need for a static website.

Save the policy to apply the settings.

🌐 Step 5: Enable Static Website Hosting
Now for the final touch — let’s tell AWS to serve this bucket as a website.

Go to the Properties tab of your bucket and scroll down to find Static website hosting. Click Edit, then enable the setting.

You’ll need to provide the name of your entry file, usually index.html. You can leave the error document field empty or add error.html if your site has one.

Click Save changes, and AWS will generate a public URL for your website in the format:

ttp://your-bucket-name.s3-website.region.amazonaws.com/
Open this link in your browser — and voila! Your website is live and accessible to the world.

🏁 Final Result
At this point, you’ve completed all the essential steps to host a website on Amazon S3:

You created a secure bucket
Uploaded all required files
Set public access and policies
Enabled static website hosting
Received a live link to your project
You can now share this link with clients, friends, or on your resume. And next time someone asks how to host a simple website, you’ll be ready!

💡 Pro Tips (Optional but Helpful)
Use IAM roles instead of root access for better security and monitoring.
Enable versioning on your bucket to track changes and recover deleted files.
Connect a custom domain via Route 53, and add CloudFront for global speed boost.
If needed, create CI/CD pipelines to auto-upload files using GitHub Actions or AWS CLI.

⚠️ What Happens to Your AWS RDS Instances After Account Suspension? Author: Naami Ahmed

Naami Ahmed — Fri, 27 Jun 2025 04:38:29 +0000

Have you ever wondered what happens to your AWS resources if your account gets suspended—especially your RDS databases?

Recently, I encountered a situation where an AWS account was suspended due to billing issues. After reactivation, some services were still there—like EC2 and VPC—but surprisingly, the RDS database instances were missing. This led me to investigate why RDS behaves differently from other services during suspension.

In this blog post, I’ll explain what I learned, how RDS is treated differently, and what you can do to protect your data.

🔍 AWS Account Suspension: What Actually Happens?
When AWS suspends your account—usually because of unpaid bills—it restricts your access to most services. However, not all resources behave the same way.

Let’s break it down:

✅ EC2 and VPC Resources

EC2 instances are stopped, not terminated.
VPC configurations (like subnets, route tables, security groups) remain intact.
After reactivating the account, EC2 instances can be restarted manually—or automatically if configured.

So far, so good.

⚠️ RDS Resources (The Catch)

Amazon RDS (Relational Database Service) behaves differently from EC2. Here’s what I found:
RDS is fully managed, meaning AWS handles the infrastructure, maintenance, and operations.
During account suspension, AWS may automatically delete RDS instances, typically within 3–7 days of the suspension.
There’s no fixed public retention policy from AWS for RDS after suspension.
AWS might delete these instances earlier to free up storage and reduce management cost, since databases require persistent storage and monitoring.

This behavior can lead to permanent data loss if you’re not prepared.

💾 Can You Recover the Deleted RDS Database?
Yes—but only if you had backups. There are two ways this could save you:

Automated Backups: If you enabled automated backups, AWS retains daily backups for a defined retention period (usually 7–35 days).
Manual Snapshots: If you manually created DB snapshots, you can restore from them any time.

When you restore from a backup or snapshot, a new RDS instance is created, and that means:

➡️ The database endpoint (URL) changes.
➡️ All connected apps must be updated with the new endpoint.

If you don’t have any backups or snapshots? Unfortunately, there’s no way to recover the data.

🔐 Best Practices to Avoid RDS Surprises
To stay safe and avoid losing your databases, follow these tips:

1. Enable Automated Backups
Make sure every RDS instance has automated backups turned on with a suitable retention period.

2. Take Regular Manual Snapshots
Automated backups can disappear after account issues. Snapshots are manual and can be kept longer—even after deletion of the instance.

**3. Use CloudWatch Billing Alerts
**Set up AWS Billing alerts to get notified when your usage charges increase or when you’re at risk of suspension.

**4. Keep a Recovery Checklist
**When recovering from account suspension or restoring a DB:

Confirm that backups exist.
Note the new endpoint.
Update connection strings in your applications.

5. Document Your Incident Recovery Plan
Have a disaster recovery plan ready—especially if your app depends heavily on RDS. A simple document can save hours of troubleshooting.

Nginx Configuration on AWS EC2 Deployment

Naami Ahmed — Sun, 13 Apr 2025 15:42:56 +0000

This guide explains how to configure an EC2 instance, install Nginx, and set up auto deployment using GitHub Actions for a UAT environment.

✅ 1. Create EC2 Instance
Steps:

Login to AWS Console → Go to EC2 Dashboard.
Launch Instance → Choose Amazon Linux 2 as your OS.
Configure basic settings like name, instance type, and network settings.
Create/Use Key Pair → This key will be used later for SSH connection.

In the Security Group, allow:

Port 22 (SSH): For connecting remotely to EC2.
Port 80 (HTTP): For regular web traffic.
Port 443 (HTTPS): For secure (SSL) web traffic.

📌 Explanation:
Security groups act like a firewall. Opening ports allows your instance to communicate with the internet properly.

🔐 2. Connect to EC2 via SSH
Windows Users (PowerShell using OpenSSH):

ssh -i "path/to/your-key.pem" ec2-user@<your-ec2-public-ip>

📌 Explanation:
This command connects your local computer to the EC2 instance using the .pem key. You need this to log in securely.

⚙️ 3. Install and Configure Nginx
For Amazon Linux 2:

sudo yum update -y
sudo amazon-linux-extras enable nginx1
sudo yum install nginx -y

For Ubuntu:

sudo apt update && sudo apt install nginx -y

Start Nginx:

sudo systemctl start nginx
sudo systemctl enable nginx

🧪 Check Nginx:
Open a browser and visit http://<your-ec2-public-ip> – You should see the default Nginx welcome page.

📌 Explanation:
Nginx is a web server used to serve your frontend app. We’re installing and starting it here.

🛠️ 4. Configure Nginx to Serve Your App
Create New Config File:

sudo nano /etc/nginx/conf.d/app-proxy.conf

Sample Config (Generic):

server {
    listen 80;
    server_name your-subdomain.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name your-subdomain.example.com;
    root /usr/share/nginx/html/your-app-folder;
    index index.html;

    location / {
        try_files $uri /index.html;
    }

    error_page 404 /404.html;

    ssl_certificate /etc/letsencrypt/live/your-domain/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your-domain/privkey.pem;
}

📌 Explanation:

First block: Redirects HTTP to HTTPS.
Second block: Serves the app using SSL (HTTPS).
root: The directory where your built frontend app files are copied.
try_files $uri /index.html: This is for frontend routing support (like React or Angular apps).
SSL certs are from Let's Encrypt (set up using Certbot separately).

Test and Restart Nginx:

sudo nginx -t
sudo systemctl restart nginx

🚀 5. Auto Deployment Using GitHub Actions

Steps:

In your GitHub repo, create folder: .github/workflows/
Inside it, add a file: deploy-uat.yml
GitHub Actions Example:

name: Deploy Frontend App to EC2 with Nginx

on:
  push:
    branches:
      - deploy

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 20

      - name: Install Dependencies
        run: npm ci --legacy-peer-deps

      - name: Build App
        env:
          CI: false
        run: |
          npm run build
          ls -l build/

      - name: Archive Build Folder
        run: tar -czf build.tar.gz -C build .

      - name: Deploy to EC2
        run: |
          echo "${{ secrets.SSH_PRIVATE_KEY }}" > my-key
          chmod 600 my-key
          scp -i my-key -o StrictHostKeyChecking=no build.tar.gz ec2-user@<EC2_PUBLIC_IP>:/usr/share/nginx/html/your-app-folder/

      - name: Extract Build on EC2
        run: |
          ssh -i my-key -o StrictHostKeyChecking=no ec2-user@<EC2_PUBLIC_IP> << EOF
            cd /usr/share/nginx/html/your-app-folder/
            if [ -f build.tar.gz ]; then
              tar -xzf build.tar.gz
              rm build.tar.gz
              echo "Deployment successful!"
            else
              echo "Error: build.tar.gz not found!"
              exit 1
            fi
          EOF

📌 Explanation:

Trigger: Runs when you push to the deploy branch.
Build: Installs dependencies and builds the frontend app.
Archive: Compresses the build files.
Upload: Sends the files to the EC2 server using scp.
Extract: Unzips files on EC2 to serve them with Nginx.

🔐 Use GitHub Secrets:
To avoid hardcoding private keys, store them as GitHub repository secrets like SSH_PRIVATE_KEY.

🧪 6. Test Auto Deployment

Make a small change in your frontend code.
Push to deploy branch.
Check GitHub → Actions tab to monitor the workflow.
Visit your subdomain or EC2 public IP to confirm the changes are live.

Automating AWS RDS Management Using IAM, Lambda, CloudWatch, and EventBridge

Naami Ahmed — Sun, 09 Mar 2025 08:30:29 +0000

Introduction

In cloud computing, cost and resource optimization are critical for efficient infrastructure management. AWS provides various services that help automate database management, enhance security, and ensure high availability. This article explores how to automate Amazon RDS instance management using AWS IAM, Lambda, CloudWatch, and EventBridge. We will walk through a common scenario, benefits, and implementation steps.

Common Scenario: Managing RDS Instance Availability

Many organizations use Amazon RDS for databases, but keeping instances running 24/7 can be costly. To optimize costs, businesses prefer running their RDS instances only during business hours. This scenario requires:

Starting RDS at 6 AM IST (before business hours begin).
Stopping RDS at 6 PM IST (after business hours end).
Automating the process to avoid manual intervention.
Monitoring performance and logs to track execution and troubleshoot issues.

Workflow

1. IAM (Identity and Access Management)IAM is used to define permissions for the Lambda function to start and stop RDS instances securely.

2. Lambda (Serverless Compute Function)AWS Lambda helps execute the function that starts and stops RDS instances based on a predefined schedule.

3. CloudWatch (Monitoring and Logging)CloudWatch is used to capture logs, monitor execution, and track failures.

4. EventBridge (Automated Scheduling)Amazon EventBridge (formerly CloudWatch Events) triggers the Lambda function based on a cron schedule, ensuring automation.

Workflow: Automating RDS Start and Stop

Create an IAM Role for Lambda with permissions to start and stop RDS instances.
Write a Lambda Function to check the time and perform the necessary action (start/stop RDS).
Set Up EventBridge Rules to schedule the function execution (6 AM IST & 6 PM IST).
Monitor Execution Logs using CloudWatch to ensure proper functioning.

Step-by-Step Implementation

Step 1: Create an IAM Role for Lambda

1. Go to the AWS IAM Console.
2. Create a new role with the following policies
3. AmazonRDSFullAccess (or custom policy with StartDBInstance & StopDBInstance permissions).
4. AWSLambdaBasicExecutionRole (for CloudWatch logging)
5. Attach this role to the Lambda function.

Step 2: Write the Lambda Function
This function will:

Fetch the current time in IST.
Determine if it’s a weekday and within working hours.
Start or stop the RDS instance accordingly

import boto3
import datetime
from dateutil import tz
import logging
import os
# Configure logging
logging.basicConfig(level=logging.INFO)
# AWS RDS Client
region = os.getenv("AWS_REGION", "us-east-1")  # Default to 'us-east-1' if not set
rds = boto3.client('rds', region_name=region)
# Configurable Tags (Default: Empty Dict)
REQUIRED_TAGS = {
    os.getenv("TAG_KEY", "Environment"): os.getenv("TAG_VALUE", "Production")
}
# Configurable Timezone (Default: UTC)
TIMEZONE = tz.gettz(os.getenv("TIMEZONE", "UTC"))
def get_tagged_rds_instances():
    """Fetches RDS instances with required tags."""
    try:
        instances = rds.describe_db_instances()['DBInstances']
        tagged_instances = []
for db in instances:
            tags = rds.list_tags_for_resource(ResourceName=db['DBInstanceArn'])['TagList']
            tag_dict = {tag['Key']: tag['Value'] for tag in tags}
# Check if all required tags match
            if all(REQUIRED_TAGS[key] == tag_dict.get(key, "") for key in REQUIRED_TAGS):
                tagged_instances.append(db['DBInstanceIdentifier'])
return tagged_instances
    except Exception as e:
        logging.error(f"Error fetching RDS instances: {str(e)}")
        return []
def lambda_handler(event, context):
    """Lambda function to start/stop RDS based on time and day."""
    now = datetime.datetime.now(tz=TIMEZONE)
    current_hour = now.hour
    current_day = now.weekday()
tagged_rds_instances = get_tagged_rds_instances()
for db_identifier in tagged_rds_instances:
        if 0 <= current_day <= 4:  # Weekdays (Monday-Friday)
            if 6 <= current_hour < 18:
                logging.info(f"Starting RDS {db_identifier}...")
                rds.start_db_instance(DBInstanceIdentifier=db_identifier)
            else:
                logging.info(f"Stopping RDS {db_identifier}...")
                rds.stop_db_instance(DBInstanceIdentifier=db_identifier)
        else:  # Weekends (Saturday-Sunday)
            logging.info(f"Stopping RDS {db_identifier} for the weekend...")
            rds.stop_db_instance(DBInstanceIdentifier=db_identifier)
return "Lambda execution completed."

Step 3: Configure EventBridge Rules

Go to Amazon EventBridge.
Create two rules:
Start RDS at 6 AM IST: cron(30 0 * * ? *) (UTC → 6:30 AM IST)
Stop RDS at 6 PM IST: cron(30 12 * * ? *) (UTC → 6:30 PM IST)
Set the target as the Lambda function.

Step 4: Monitor Execution Using CloudWatch

Go to CloudWatch Logs.
Navigate to the log group for your Lambda function.
Check execution details, errors, or any unexpected behaviors.

Benefits of This Approach
✅ Cost Optimization — RDS instances run only when needed, reducing AWS costs.
✅ Automation — Eliminates manual intervention and improves efficiency.
✅ Security & Access Control — IAM roles restrict unnecessary access.
✅ Monitoring & Logging — CloudWatch ensures visibility into function execution.
✅ Scalability — Easily extend this setup for multiple RDS instances.

Conclusion
Automating Amazon RDS using IAM, Lambda, CloudWatch, and EventBridge is a powerful way to optimize cloud resources efficiently. By implementing this workflow, businesses can reduce costs, improve reliability, and maintain secure access control.

This setup can be further enhanced by integrating SNS notifications for alerts or using AWS Systems Manager for more complex automation tasks.

AWS EC2 (Elastic Compute Cloud)

Naami Ahmed — Sun, 05 Jan 2025 04:37:33 +0000

Introduction
Amazon EC2 (Elastic Compute Cloud) is a web service that provides resizable compute capacity in the cloud. It is designed to make web-scale cloud computing easier for developers by offering scalable, flexible, and cost-effective compute resources.

Overview of Amazon EC2
Elastic Compute Capacity: EC2 allows you to scale your compute capacity up or down based on your needs.
Instances: Virtual servers for running applications. Instances can be launched in multiple regions and availability zones to ensure high availability.
Instance Types: EC2 offers a variety of instance types optimized for different purposes, such as general-purpose, compute-optimized, memory-optimized, storage-optimized, and GPU instances.
Pricing Models:

On-Demand Instances: Pay for compute capacity by the hour or second with no long-term commitments.
Reserved Instances: Purchase instances for a significant discount compared to On-Demand pricing.
Spot Instances: Bid on spare EC2 capacity and run instances for even lower costs.
Savings Plans: Flexible pricing model offering lower prices on EC2 usage in exchange for a commitment to a consistent amount of usage (measured in $/hour) for a 1- or 3-year term.

Key Features of Amazon EC2
Scalability: EC2 allows you to automatically scale your infrastructure up or down based on demand using Auto Scaling.
Flexibility: Choose from a wide range of instance types to fit different use cases, ensuring optimal performance for your applications.
Reliability: EC2 instances are hosted in multiple locations worldwide, providing high availability and fault tolerance.
Security: EC2 integrates with AWS Identity and Access Management (IAM) to provide robust security features such as security groups, key pairs, and IAM roles.
Networking: Options include Virtual Private Cloud (VPC) for isolated networks, Elastic IP addresses for static IPs, and Elastic Load Balancing for distributing traffic across instances.

Use Cases for Amazon EC2
Web Hosting: Run scalable and reliable web applications with the ability to handle varying levels of traffic.
Big Data: Process and analyze large datasets using EC2 instances optimized for high performance.
Development and Testing: Quickly create and scale environments for development and testing purposes.
Machine Learning: Train and deploy machine learning models on powerful GPU instances.
Gaming: Host gaming servers with low latency and high availability.

Benefits of Amazon EC2
Cost-Effective: Only pay for the compute capacity you actually use, with options to save costs through Reserved Instances and Spot Instances.
High Performance: Choose from a variety of instance types optimized for specific workloads to ensure optimal performance.
Global Reach: Deploy instances in multiple regions worldwide, bringing your applications closer to your users.
Secure: Built-in security features and compliance certifications ensure your data and applications are protected.

Conclusion
Amazon EC2 provides scalable, flexible, and cost-effective compute capacity in the cloud. By leveraging its features and following best practices, you can effectively manage and optimize your cloud infrastructure, ensuring high performance and security for your applications.