Forem: Fazly Fathhy

Serverless Architecture and the Role of AWS Lambda in Modern Cloud Computing

Fazly Fathhy — Mon, 13 Oct 2025 01:22:58 +0000

In today’s rapidly evolving technology landscape, businesses are constantly seeking ways to improve efficiency, scalability, and cost-effectiveness. One of the most transformative innovations in cloud computing that helps achieve these goals is serverless architecture. This approach allows developers to focus on writing code without the burden of managing servers, scaling infrastructure, or handling complex deployment pipelines. Among the many services that power the serverless revolution, AWS Lambda stands out as a key enabler

What is Serverless Architecture?

Serverless architecture is a cloud computing execution model where the cloud provider dynamically manages the allocation and provisioning of servers. Despite the name, servers are still used — but the responsibility of maintaining and operating them is completely handled by the cloud provider.

In a serverless model:

Developers write and deploy code in the form of functions.
These functions are executed only when triggered by specific events(like an API call, file upload, or database update).
The cloud provider automatically handles scaling, monitoring, and resource management.

This results in reduced operational complexity, better scalability, and a pay-as-you-go pricing model—you only pay for the compute time you actually use.

Key Benefits of Serverless Architecture

No Server Management:
Developers don’t need to provision, scale, or maintain servers. The cloud provider handles it all.
Automatic Scaling:
Serverless platforms automatically scale applications up or down depending on the workload.
Cost Efficiency:
You only pay for execution time — not idle resources.
Faster Deployment and Innovation:
Since the infrastructure is managed by the cloud provider, developers can focus on business logic and innovation rather than infrastructure tasks.
Event-Driven Execution:
Functions are executed in response to events, making the system highly efficient and responsive.

AWS Lambda: The Core of Serverless on AWS

AWS Lambda is Amazon Web Services’ (AWS) serverless compute service. It allows developers to run code without provisioning or managing servers. Introduced in 2014, Lambda has become the backbone of AWS’s serverless offerings and plays a major role in shaping modern cloud architectures.

How AWS Lambda Works

With AWS Lambda, you simply:

Write your function code in a supported language (such as Python, Node.js, Java, Go, or C#).
Upload the code to AWS Lambda or link it through the AWS Management Console or CLI.
Define the event that will trigger your function (e.g., an API Gateway request, S3 file upload, or DynamoDB table update).

Lambda automatically handles:

The provisioning of compute resources.
Running your function in response to triggers.
Scaling up and down based on demand.
Logging and monitoring through Amazon CloudWatch.

Key Features and Contributions of AWS Lambda

Event-Driven Execution Model:
Lambda integrates with over 200 AWS services, allowing it to respond to events such as S3 uploads, API calls, or SNS messages instantly.
Automatic Scaling:
Each function runs in its own isolated environment and scales automatically with incoming requests — from a few requests per day to thousands per second.
Cost Optimization:
AWS Lambda charges are based on the number of requests and execution duration. You pay only for the time your code runs, down to the millisecond.
Seamless Integration with AWS Ecosystem:
Lambda easily connects with other AWS services like API Gateway, S3, DynamoDB, SNS, and Step Functions, enabling complete serverless workflows.
Security and Reliability:
Lambda functions run within secure, isolated environments with IAM roles and permissions to control access, ensuring secure operations.
Simplified Development and Deployment:
With frameworks like AWS SAM (Serverless Application Model) and Serverless Framework, developers can define, deploy, and manage Lambda-based applications efficiently.

features that make AWS Lambda different and often more advanced compared to other serverless platforms

Deep Integration with AWS Ecosystem

AWS Lambda is tightly integrated with more than 200 AWS services, which allows you to build end-to-end solutions easily.
For example:

Triggers: Lambda can be directly triggered by events from S3, DynamoDB, SNS, Kinesis, CloudWatch, EventBridge, and API Gateway.
Outputs: Lambda functions can automatically send results to other AWS services like SQS, SNS, Step Functions, or even custom APIs.

Broad Language Support and Custom Runtimes

AWS Lambda supports multiple programming languages by default, including:

Node.js
Python
Java
Go
Ruby
.NET Core

But what really sets it apart is the Custom Runtime feature, allowing developers to run any programming language by bringing their own runtime using AWS Lambda Layers.

AWS Lambda Layers

Lambda Layers let you separate common code and dependencies (like libraries, SDKs, or configuration files) from your main function code.
This promotes cleaner, modular development and reduces deployment size.

Provisioned Concurrency

One of the biggest criticisms of serverless computing is “cold start” latency — the delay when a function runs after being idle.
AWS Lambda solves this with Provisioned Concurrency, which keeps functions “warm” and ready to respond instantly.

Fine-Grained Security and Permissions (IAM Integration)

Lambda integrates directly with AWS Identity and Access Management (IAM), giving developers precise control over what each function can access.
You can assign unique IAM roles per function, securing your application at a granular level.

EventBridge and Step Functions Integration

AWS Lambda works natively with AWS Step Functions to build complex workflows and with EventBridge for event-driven architectures.
This enables serverless orchestration — you can chain multiple Lambda functions with retries, parallel execution, and error handling.

Cost and Scalability Advantages

Lambda’s billing model is very precise:

You’re charged only for the execution time (in milliseconds) and number of requests.
Automatic scaling from zero to thousands of concurrent executions without manual intervention.

Versioning and Aliases

Lambda supports function versioning and aliases (like dev, test, prod), enabling smooth deployment strategies such as:

Blue/Green deployments
Canary releases
Rollbacks to previous versions

Commonly Confused AWS Services

Fazly Fathhy — Sun, 10 Aug 2025 06:24:34 +0000

1. Amazon SNS vs Amazon SQS
*SNS = Publish/Subscribe broadcast;
SQS = Message queue for processing;

2. Amazon EBS vs Amazon EFS vs Amazon S3
EBS = Block storage for one EC2;
EFS = Shared file system for many EC2
S3 = Object storage for any scale and anywhere

3. AWS CloudWatch vs AWS CloudTrail
CloudWatch = Performance/metrics;
CloudTrail = Activity & API audit;

4. Auto Scaling vs Elastic Load Balancing
Auto Scaling = Adjusts instance count;
ELB = Distributes incoming traffic;

5. IAM Roles vs IAM Policies
Roles = Identities with permissions;
Policies = Permission definitions;

6. RDS vs DynamoDB
RDS = Managed SQL DB;
DynamoDB = Managed NoSQL DB

7. NAT Gateway vs Internet Gateway
NAT GW = Outbound internet from private subnets;
IGW = Full internet access

8. VPC Peering vs VPN vs Direct Connect
VPC Peering = Private AWS-to-AWS link;
VPN = Secure internet link to on-prem

9. AWS Lambda vs AWS Fargate
Lambda = Event-driven functions;
Fargate = Serverless container hosting;

10. AWS Config vs AWS Systems Manager
Config = Tracks changes & compliance;
SSM = Automates operations & management

*** Many AWS services complement each other — the confusion often comes from overlapping names, not overlapping functionality.**

🚀 Introduction to Amazon EKS – AWS Managed Kubernetes Service

Fazly Fathhy — Fri, 30 May 2025 11:35:45 +0000

Kubernetes (K8s) has become the de facto standard for container orchestration, but setting it up and managing its control plane can be complex and time-consuming. This is where Amazon Elastic Kubernetes Service (EKS) comes in—a fully managed Kubernetes service offered by AWS that simplifies cluster management while providing scalability, security, and high availability out of the box.

🔧 What is EKS?

Amazon EKS is AWS's managed Kubernetes service. It helps you run Kubernetes without needing to install and operate your own control plane or manage master nodes. AWS handles the heavy lifting, so you can focus on deploying and scaling your applications.

Key Features of EKS:

AWS-managed Control Plane:
EKS automatically provisions and manages the Kubernetes control plane, ensuring high availability and secure operations.

Master Node Management:
You don’t need to manage or maintain master nodes—AWS takes care of this for you.

Control Plane Components Installed by AWS:

API Server – Handles communication between the Kubernetes components and user commands.
Scheduler – Assigns workloads to specific nodes based on resource availability and requirements.
Controller Manager – Governs the cluster state, ensuring the desired number of pods and other resources.
etcd – The key-value store that acts as Kubernetes’ backing store for all cluster data.

🤔 Why Use EKS?

Fully managed: Focus on your workloads rather than infrastructure.

Highly available and secure: AWS distributes the control plane across multiple Availability Zones (AZs).

Integrated wthe AWS AWS ecosystem: Leverage IAM, VPC, CloudWatch, and other services easily.

Scalable: Handle production workloads with ease, whether small-scale or enterprise-level.

Certified Kubernetes: Easily migrate applications to/from other Kubernetes environments.

⚙️ Worker Nodes in EKS

While AWS manages the control plane, you have options when it comes to managing worker nodes—the nodes that run your actual container workloads.

Self-managed Nodes
You provision EC2 instances manually and join them to your EKS cluster.
Full control over node configurations, AMIs, instance types, and lifecycle.
Ideal for advanced use cases where custom configuration or integration is needed.
Requires you to handle updates, scaling, and security patches.
Managed Node Groups
AWS provisions and manages EC2 instances for you within an Auto Scaling group.
Easier to set up and operate compared to self-managed nodes.
Supports automatic upgrades and lifecycle management.
Integrated with AWS CloudFormation and IAM.
AWS Fargate
A serverless compute engine for containers.
No need to manage EC2 instances at all—AWS runs your containers on demand.
Ideal for applications with variable workloads or short-lived tasks.
Reduced operational overhead and improved cost-efficiency for small to medium workloads.

Tech Letter to RAJ

Fazly Fathhy — Sat, 01 Mar 2025 06:12:08 +0000

Dear Raj,

I hope this letter finds you well.Machcahn, Do you know how quickly technology is transforming the world around us. The pace of innovation is astonishing, and I wanted to take sometimes to share my expriences about this Changes.

One of the most exciting advancements is the rise of cloud technologies. Cloud computing has revolutionized the way we store, access, and process data. Businesses are increasingly moving away from traditional on-premise systems to cloud-based infrastructures, making operations more efficient, scalable, and cost-effective. With platforms like AWS, Google Cloud, and Microsoft Azure, companies can deploy applications globally in minutes, improving accessibility and performance.

Is that exitable no?
do you know?
The internet is also evolving rapidly. With the expansion of 5G and the potential of Web3, our online experiences are becoming faster and more decentralized. Cloud technologies are playing a critical role in enabling these advancements, allowing businesses to scale their applications efficiently while ensuring high availability and security.

On the sustainability front, cloud computing is helping reduce the environmental impact of technology. Many providers are adopting green data centers powered by renewable energy, optimizing energy consumption, and minimizing waste. Cloud-based solutions also allow businesses to reduce their carbon footprint by replacing physical infrastructure with virtualized resources.

As we embrace these changes, it's essential to stay informed, adapt, and make the most of the opportunities that come with innovation. Cloud technologies are reshaping the job market, creating new career paths in DevOps, cloud security, and cloud architecture. Continuous learning will be key to staying ahead.

I’d love to hear your thoughts on these trends and how you see technology shaping our future. Let’s keep the conversation going and explore ways we can leverage these advancements to improve our lives and careers.

Looking forward to catching up soon!

Best regards,
Fathhy Ahamed

🚀 Portfolio Live Now!

Fazly Fathhy — Sat, 01 Mar 2025 05:56:17 +0000

Thrilled to share that I’ve just developed and deployed my personal portfolio! 🎉 This marks another milestone in my journey as a DevOps engineer and software developer.

Check it out here: https://my-portfolio-main-puce.vercel.app/ and let me know your thoughts! 🔥

DevOps #WebDevelopment #Portfolio #Deployment #TechJourney

Let me know if you’d like any modifications! 😊

Terraform

Fazly Fathhy — Sun, 02 Feb 2025 20:00:09 +0000

Terraform is an infrastructure as code (IaC) tool created by HashiCorp. It allows you to define, provision, and manage cloud and on-premises resources in a declarative configuration language. With Terraform, you can automate the deployment and management of infrastructure across multiple cloud providers (like AWS, Azure, Google Cloud, etc.) and other services.

Key Features of Terraform:

Declarative Configuration: You define what you want your infrastructure to look like in code (using HashiCorp Configuration Language, or HCL), and Terraform figures out how to achieve it.
Multi-Cloud Support: Works with multiple cloud providers and services, making it a versatile tool for hybrid or multi-cloud environments.
State Management: Terraform keeps track of the state of your infrastructure, allowing it to understand what changes need to be made to reach the desired state.
Plan and Apply: Terraform provides a "plan" phase to preview changes before applying them, reducing the risk of unintended modifications.
Modularity: You can create reusable modules to simplify and standardize infrastructure configurations.
Version Control: Infrastructure code can be versioned and stored in repositories like Git, enabling collaboration and tracking changes over time.

How Terraform Works:
Write configuration files (.tf files) describing the desired infrastructure.

Run terraform init to initialize the working directory and download necessary providers.

Run terraform plan to see what changes Terraform will make.

Run terraform apply to apply the changes and provision the infrastructure.

Use terraform destroy to tear down the infrastructure when it's no longer needed.

Example Use Cases:
Automating the creation of cloud resources (e.g., virtual machines, networks, databases).

Managing Kubernetes clusters or containerized environments.

Setting up CI/CD pipelines with infrastructure dependencies.

Enforcing consistent infrastructure across development, staging, and production environments.

Terraform is widely used by DevOps teams to manage infrastructure efficiently, reduce human error, and ensure reproducibility. Let me know if you'd like a deeper dive or examples! 😊

Frontend Challenge - December Edition

Fazly Fathhy — Sat, 21 Dec 2024 16:50:31 +0000

This is a submission for Frontend Challenge - December Edition, Glam Up My Markup: Winter Solstice

What I Built

This is the page for advertising the Wonderland Event for Christmas edition

Demo

Journey

I am an undergraduate student,so I learn web developing in the University, but i change my path into Devops so i didn't develop any websites in last 1 year, but I try my best for this website

Source Code

https://github.com/FAZLY-FATHHY/Dev-Challenge.git

My First Full-Stack Deployment with Docker and NGINX as Load Balancer

Fazly Fathhy — Sat, 07 Dec 2024 18:08:08 +0000

Introduction:

In this post, I’ll walk through my experience creating a full-stack application with a simple frontend and backend. The frontend is a basic HTML file, while the backend is built with Node.js. After containerizing both with Docker, I set up NGINX as a reverse proxy and load balancer to manage traffic across multiple backend instances. This project was an important step in learning about Docker, NGINX, and full-stack deployment.

**Step 1: Building the Frontend and Backend
Frontend:

**
The frontend is a simple HTML page that interacts with the backend. It could be a webpage that makes requests to the backend or displays data dynamically.

Frontend Code: I created a basic index.html file that is served via Docker. It could be as simple as displaying a simple frontend and making API requests to the Node.js backend.

Backend:
The backend is a Node.js application that listens on specific ports (3001, 3002, 3003). It serves data or processes requests sent from the frontend.

*Step 2: Containerizing with Docker
*
Docker Image:
I wrote a Dockerfile to containerize the HTML file and serve it with a simple web server like nginx.

Step 3: Setting Up NGINX

Now that the frontend and backend are containerized and running, I set up NGINX as a reverse proxy and load balancer. NGINX will forward incoming traffic to the appropriate backend service.

NGINX Configuration:
I created an NGINX configuration file (nginx.conf) to manage multiple backend instances. Here's the configuration I used:

Installing NGINX in linux

Fazly Fathhy — Sat, 07 Dec 2024 09:10:43 +0000

To install NGINX on a Linux system, follow these steps based on the Linux distribution you are using. Here's a guide for common distributions like Ubuntu/Debian and CentOS/RHEL.

Step 1: Update the Package List
*sudo apt update

Step 2: Install NGINX
*sudo apt install nginx -y

Step 3: Start and Enable NGINX
*sudo systemctl start nginx
*sudo systemctl enable nginx

Step 4: Verify the Installation

Open your browser and navigate to http:// or http://localhost.
You should see the default NGINX welcome page.

Spread Spectrum In spread spectrum (SS), we combine signals from different sources to fit into a larger bandwidth, but our goals are to prevent eavesdropping and jamming. To achieve these goals, spread spectrum techniques add redundancy.

Fazly Fathhy — Thu, 05 Dec 2024 18:00:26 +0000

Terraform : Simplifying Infrastructure as Code for Modern DevOps

Fazly Fathhy — Wed, 04 Dec 2024 15:02:21 +0000

Infrastructure as Code (IaC) has revolutionized how we manage and provision infrastructure, and Terraform is one of the most powerful tools in this space. Whether you're a beginner exploring IaC or a seasoned DevOps professional, understanding Terraform is crucial to building and managing scalable, reliable infrastructure efficiently.

What is Terraform?

Terraform, developed by HashiCorp, is an open-source tool that allows you to define your infrastructure in code. This approach enables you to manage resources such as servers, storage, networks, and even entire Kubernetes clusters declaratively.

Key Features of Terraform

Declarative Configuration: Define what your infrastructure should look like, and Terraform will make it happen.
State Management: Keep track of your infrastructure's current state for easier updates and changes.
Provider Support: Terraform supports major cloud providers like AWS, Azure, Google Cloud, and even on-premises solutions.
Modularity: Write reusable code with modules for standardized and scalable deployments.
Plan and Apply: Preview changes with terraform plan before applying them, ensuring safety and predictability.

Why Use Terraform?

Consistency: Terraform ensures consistent infrastructure provisioning across environments (dev, staging, production).
Automation: Automate repetitive tasks, reducing human errors.
Collaboration: Share and version control infrastructure code using Git or other VCS tools.
Multi-cloud Support: Manage resources across multiple providers seamlessly.

Minikube....

Fazly Fathhy — Tue, 03 Dec 2024 14:06:59 +0000

Minikube is a lightweight tool that allows you to run a single-node Kubernetes cluster locally on your machine. It is commonly used for learning, development, and testing purposes because it provides an easy way to experiment with Kubernetes without requiring a full-scale cluster setup.

Key Features of Minikube:

Local Kubernetes Cluster: It runs Kubernetes in a virtual machine or container, allowing you to use Kubernetes commands (kubectl) to interact with the cluster.
Supports Multiple Platforms: Works on Linux, macOS, and Windows.
Customizable Cluster Configurations: You can specify the number of CPUs, memory, and Kubernetes versions during setup.
Integrated Add-ons: Minikube includes useful add-ons such as:
Ingress: To manage external access to services.
Dashboard: A user-friendly interface to interact with Kubernetes resources.
Storage: Persistent storage for your workloads.
Metrics Server: For monitoring resource usage in the cluster.
Container Runtime Options: Supports different runtimes like Docker, containerd, and CRI-O.
LoadBalancer Emulation: Simulates LoadBalancer services in environments that don't natively support them (e.g., your local machine).

start the minikube with - 'minikube start'