DEV Community: Ragul.M

Setting Up Kubernetes and Nginx Ingress Controller on an EC2 Instance

Ragul.M — Wed, 19 Mar 2025 16:52:47 +0000

Introduction

Kubernetes (K8s) is a powerful container orchestration platform that simplifies application deployment and scaling. In this guide, we’ll set up Kubernetes on an AWS EC2 instance, install the Nginx Ingress Controller, and configure Ingress rules to expose multiple services (app1 and app2).

Step 1: Setting Up Kubernetes on an EC2 Instance
1.1 Launch an EC2 Instance
Choose an instance with enough resources (e.g., t3.medium or larger) and install Ubuntu 20.04 or Amazon Linux 2.
1.2 Update Packages

sudo apt update && sudo apt upgrade -y  # For Ubuntu

1.3 Install Docker

sudo apt install -y docker.io  
sudo systemctl enable --now docker

1.4 Install Kubernetes (kubectl, kubeadm, kubelet)

sudo apt install -y apt-transport-https ca-certificates curl
sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt update
sudo apt install -y kubelet kubeadm kubectl

1.5 Initialize Kubernetes

sudo kubeadm init --pod-network-cidr=192.168.0.0/16

Follow the output instructions to set up kubectl for your user:

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

1.6 Install a Network Plugin (Calico)

For Calico:
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

Now, Kubernetes is ready!

Step 2: Install Nginx Ingress Controller
Nginx Ingress Controller helps manage external traffic to services inside the cluster.

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml

Wait until the controller is running:

kubectl get pods -n ingress-nginx

You should see ingress-nginx-controller running.

Step 3: Deploy Two Applications (app1 and app2)
3.1 Deploy app1
Create app1-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app1
spec:
  replicas: 2
  selector:
    matchLabels:
      app: app1
  template:
    metadata:
      labels:
        app: app1
    spec:
      containers:
      - name: app1
        image: nginx
        ports:
        - containerPort: 80

Create app1-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: app1-service
spec:
  selector:
    app: app1
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP

Apply the resources:

kubectl apply -f app1-deployment.yaml 
kubectl apply -f app1-service.yaml

3.2 Deploy app2
Create app2-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app2
spec:
  replicas: 2
  selector:
    matchLabels:
      app: app2
  template:
    metadata:
      labels:
        app: app2
    spec:
      containers:
      - name: app2
        image: nginx
        ports:
        - containerPort: 80

Create app2-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: app2-service
spec:
  selector:
    app: app2
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP

Apply the resources:

kubectl apply -f app2-deployment.yaml 
kubectl apply -f app2-service.yaml

Step 4: Configure Ingress for app1 and app2
Create nginx-ingress.yaml:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: app1.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app1-service
            port:
              number: 80
  - host: app2.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app2-service
            port:
              number: 80

Apply the Ingress rule:

kubectl apply -f nginx-ingress.yaml

Step 5: Verify Everything
5.1 Get Ingress External IP

kubectl get ingress

5.2 Update /etc/hosts (Local Testing Only)
If you're testing on a local machine, add this to /etc/hosts:

<EXTERNAL-IP> app1.example.com
<EXTERNAL-IP> app2.example.com

Replace with the actual external IP of your Ingress Controller.
5.3 Test in Browser or Curl

curl http://app1.example.com
curl http://app2.example.com

If everything is set up correctly, you should see the default Nginx welcome page for both applications.

Conclusion
In this guide, we:

Installed Kubernetes on an EC2 instance
Set up Nginx Ingress Controller
Deployed two services (app1 and app2)
Configured Ingress to expose them via domain names

Now, you can easily manage multiple applications in your cluster using a single Ingress resource.

Follow for more . Happy learning :)

Deploying a Two-Tier Web Application on AWS with MySQL and Apache

Ragul.M — Wed, 12 Mar 2025 12:46:23 +0000

In this blog, I will guide you through step-by-step instructions to set up a two-tier architecture on AWS using VPC, Subnets, Internet Gateway, Route Tables, RDS, EC2, Apache, MySQL, PHP, and HTML. This project will allow you to host a registration web application where users can submit their details, which will be stored in an RDS MySQL database.

Step 1: Create a VPC
1.1 Login to AWS Management Console

Navigate to the VPC service
Click Create VPC
Enter the following details:
VPC Name: my-vpc
IPv4 CIDR Block: 10.0.0.0/16
Tenancy: Default
Click Create VPC

Step 2: Create Subnets
2.1 Create a Public Subnet

Go to VPC > Subnets
Click Create Subnet
Choose my-vpc
Set Subnet Name: public-subnet
IPv4 CIDR Block: 10.0.1.0/24
Click Create

2.2 Create a Private Subnet
Repeat the steps above but set:

Subnet Name: private-subnet
IPv4 CIDR Block: 10.0.2.0/24

Step 3: Create an Internet Gateway (IGW) and Attach to VPC
3.1 Create IGW

Go to VPC > Internet Gateways
Click Create Internet Gateway
Set Name: your-igw
Click Create IGW 3.2 Attach IGW to VPC
Select your-igw
Click Actions > Attach to VPC
Choose my-vpc and click Attach

Step 4: Configure Route Tables
4.1 Create a Public Route Table

Go to VPC > Route Tables
Click Create Route Table
Set Name: public-route-table
Choose my-vpc and click Create
Edit Routes → Add a new route:
Destination: 0.0.0.0/0
Target: my-igw
Edit Subnet Associations → Attach public-subnet

Step 5: Create an RDS Database (MySQL)

Go to RDS > Create Database
Choose Standard Create
Select MySQL
Set DB instance identifier: my-rds
Master Username: admin
Master Password: yourpassword
Subnet Group: Select private-subnet
VPC Security Group: Allow 3306 (MySQL) from my-vpc
Click Create Database

Step 6: Launch an EC2 Instance

Go to EC2 > Launch Instance
Choose Ubuntu 22.04
Set Instance Name: my-ec2
Select my-vpc and attach public-subnet
Security Group: Allow
SSH (22) from your IP
HTTP (80) from anywhere
MySQL (3306) from my-vpc
Click Launch Instance

Step 7: Install Apache, PHP, and MySQL Client
7.1 Connect to EC2

ssh -i your-key.pem ubuntu@your-ec2-public-ip

7.2 Install LAMP Stack

sudo apt update && sudo apt install -y apache2 php libapache2-mod-php php-mysql mysql-client

7.3 Start Apache

sudo systemctl start apache2
sudo systemctl enable apache2

Step 8: Configure Web Application
8.1 Create the Registration Form

cd /var/www/html

sudo nano index.html

<!DOCTYPE html>
<html>
<head>
    <title>Registration Form</title>
</head>
<body>
    <h2>User Registration</h2>
    <form action="submit.php" method="POST">
        Name: <input type="text" name="name" required><br>
        DOB: <input type="date" name="dob" required><br>
        Email: <input type="email" name="email" required><br>
        <input type="submit" value="Register">
    </form>
</body>
</html>

8.2 Create PHP Script (submit.php)

sudo nano /var/www/html/submit.php

<?php
$servername = "your-rds-endpoint";
$username = "admin";
$password = "yourpassword";
$dbname = "registration";
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}
$name = $_POST['name'];
$dob = $_POST['dob'];
$email = $_POST['email'];
$stmt = $conn->prepare("INSERT INTO users (name, dob, email) VALUES (?, ?, ?)");
$stmt->bind_param("sss", $name, $dob, $email);
if ($stmt->execute()) {
    echo "Registration successful";
} else {
    echo "Error: " . $stmt->error;
}
$stmt->close();
$conn->close();
?>

Step 9: Create Target Group

Go to the AWS EC2 Console → Navigate to Target Groups
Click Create target group
Choose Target type: Instance
Enter Target group name: my-target-group
Select Protocol: HTTP
Select Port: 80
Choose the VPC you created earlier
Click Next
Under Register Targets, select your EC2 instances
Click Include as pending below, then Create target group

Step 10: Create an Application Load Balancer (ALB)

Go to AWS EC2 Console → Navigate to Load Balancers
Click Create Load Balancer
Choose Application Load Balancer
Enter ALB Name: my-alb
Scheme: Internet-facing
IP address type: IPv4
Select the VPC
Select at least two public subnets (for high availability)
Click Next

Step 11: Test the Application

Restart Apache sudo systemctl restart apache2
Open your browser and visit: http://your-ec2-public-ip/
Fill in the form and Submit
Check MySQL Database:

mysql -u admin -p -h your-rds-endpoint
USE your_database;
SELECT * FROM table_name;

This setup ensures a scalable, secure, and high-availability application on AWS! 🚀

Follow for more and happy learning :)

Deploying a Scalable AWS Infrastructure with VPC, ALB, and Target Groups Using Terraform

Ragul.M — Tue, 11 Mar 2025 06:01:20 +0000

Introduction
In this blog, we will walk through the process of deploying a scalable AWS infrastructure using Terraform. The setup includes:

A VPC with public and private subnets
An Internet Gateway for public access
Application Load Balancers (ALBs) for distributing traffic
Target Groups and EC2 instances for handling incoming requests
By the end of this guide, you’ll have a highly available setup with proper networking, security, and load balancing.

Step 1: Creating a VPC with Public and Private Subnets
The first step is to define our Virtual Private Cloud (VPC) with four subnets (two public, two private) spread across multiple Availability Zones.
Terraform Code: vpc.tf

resource "aws_vpc" "main_vpc" {
  cidr_block = "10.0.0.0/16"
}
# Public Subnet 1 - ap-south-1a
resource "aws_subnet" "public_subnet_1" {
  vpc_id            = aws_vpc.main_vpc.id
  cidr_block        = "10.0.1.0/24"
  availability_zone = "ap-south-1a"
  map_public_ip_on_launch = true
}
# Public Subnet 2 - ap-south-1b
resource "aws_subnet" "public_subnet_2" {
  vpc_id            = aws_vpc.main_vpc.id
  cidr_block        = "10.0.2.0/24"
  availability_zone = "ap-south-1b"
  map_public_ip_on_launch = true
}
# Private Subnet 1 - ap-south-1a
resource "aws_subnet" "private_subnet_1" {
  vpc_id            = aws_vpc.main_vpc.id
  cidr_block        = "10.0.3.0/24"
  availability_zone = "ap-south-1a"
}
# Private Subnet 2 - ap-south-1b
resource "aws_subnet" "private_subnet_2" {
  vpc_id            = aws_vpc.main_vpc.id
  cidr_block        = "10.0.4.0/24"
  availability_zone = "ap-south-1b"
}
# Internet Gateway for Public Access
resource "aws_internet_gateway" "igw" {
  vpc_id = aws_vpc.main_vpc.id
}
# Public Route Table
resource "aws_route_table" "public_rt" {
  vpc_id = aws_vpc.main_vpc.id
}
resource "aws_route" "internet_access" {
  route_table_id         = aws_route_table.public_rt.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.igw.id
}
resource "aws_route_table_association" "public_assoc_1" {
  subnet_id      = aws_subnet.public_subnet_1.id
  route_table_id = aws_route_table.public_rt.id
}
resource "aws_route_table_association" "public_assoc_2" {
  subnet_id      = aws_subnet.public_subnet_2.id
  route_table_id = aws_route_table.public_rt.id
}

This configuration ensures that our public subnets can access the internet, while our private subnets remain isolated.

Step 2: Setting Up Security Groups
Next, we define security groups to control access to our ALBs and EC2 instances.
Terraform Code: security_groups.tf

resource "aws_security_group" "alb_sg" {
  vpc_id = aws_vpc.main_vpc.id
  # Allow HTTP and HTTPS traffic to ALB
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  # Allow outbound traffic
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

This allows public access to the ALB but restricts other traffic.

Step 3: Creating the Application Load Balancers (ALB)
Now, let’s define two ALBs—one public and one private.
Terraform Code: alb.tf

# Public ALB
resource "aws_lb" "public_alb" {
  name               = "public-alb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.alb_sg.id]
  subnets           = [aws_subnet.public_subnet_1.id, aws_subnet.public_subnet_2.id]
}
# Private ALB
resource "aws_lb" "private_alb" {
  name               = "private-alb"
  internal           = true
  load_balancer_type = "application"
  security_groups    = [aws_security_group.alb_sg.id]
  subnets           = [aws_subnet.private_subnet_1.id, aws_subnet.private_subnet_2.id]
}

This ensures redundancy and distributes traffic across different subnets.

Step 4: Creating Target Groups for EC2 Instances
Each ALB needs target groups to route traffic to EC2 instances.
Terraform Code: target_groups.tf

resource "aws_lb_target_group" "public_tg" {
  name     = "public-tg"
  port     = 80
  protocol = "HTTP"
  vpc_id   = aws_vpc.main_vpc.id
}
resource "aws_lb_target_group" "private_tg" {
  name     = "private-tg"
  port     = 80
  protocol = "HTTP"
  vpc_id   = aws_vpc.main_vpc.id
}

These target groups allow ALBs to forward requests to backend EC2 instances.

Step 5: Launching EC2 Instances
Finally, we deploy EC2 instances and register them with the target groups.
Terraform Code: ec2.tf

resource "aws_instance" "public_instance" {
  ami           = "ami-0abcdef1234567890" # Replace with a valid AMI ID
  instance_type = "t2.micro"
  subnet_id     = aws_subnet.public_subnet_1.id
}
resource "aws_instance" "private_instance" {
  ami           = "ami-0abcdef1234567890" # Replace with a valid AMI ID
  instance_type = "t2.micro"
  subnet_id     = aws_subnet.private_subnet_1.id
}

These instances will serve web requests.

Step 6: Registering Instances to Target Groups

resource "aws_lb_target_group_attachment" "public_attach" {
  target_group_arn = aws_lb_target_group.public_tg.arn
  target_id        = aws_instance.public_instance.id
}
resource "aws_lb_target_group_attachment" "private_attach" {
  target_group_arn = aws_lb_target_group.private_tg.arn
  target_id        = aws_instance.private_instance.id
}

This registers our EC2 instances as backend servers.

Final Step: Terraform Apply!
Run the following command to deploy everything:

terraform init
terraform apply -auto-approve

Once completed, you’ll get ALB DNS names, which you can use to access your deployed infrastructure.

Conclusion
This guide covered how to deploy a highly available AWS infrastructure using Terraform, including VPC, subnets, ALBs, security groups, target groups, and EC2 instances. This setup ensures a secure and scalable architecture.

Follow for more and happy learning :)

Managing EKS Clusters Using AWS Lambda: A Step-by-Step Approach

Ragul.M — Fri, 20 Dec 2024 12:20:54 +0000

Efficiently managing Amazon Elastic Kubernetes Service (EKS) clusters is critical for maintaining cost-effectiveness and performance. Automating the process of starting and stopping EKS clusters using AWS Lambda ensures optimal utilization and reduces manual intervention. Below is a structured approach to achieve this.

1. Define the Requirements

Identify the clusters that need automated start/stop operations.
Determine the dependencies among clusters, if any, to ensure smooth transitions.
Establish the scaling logic, such as leveraging tags to specify operational states (e.g., auto-start, auto-stop).

2. Prepare the Environment

AWS CLI Configuration: Ensure the AWS CLI is set up with appropriate credentials and access.
IAM Role for Lambda:
- Create a role with permissions to manage EKS clusters (eks:DescribeCluster, eks:UpdateNodegroupConfig, etc.).
- Include logging permissions for CloudWatch Logs to monitor the Lambda function execution.

3. Tag EKS Clusters

Use resource tagging to identify clusters for automation.
Example tags:
- auto-start=true: Indicates clusters that should be started by the Lambda function.
- dependency=<cluster-name>: Specifies any inter-cluster dependencies.

4. Design the Lambda Function

Trigger Setup:
- Use CloudWatch Events or schedule triggers (e.g., daily or weekly) to invoke the function.
Environment Variables: Configure the function with environment variables for managing cluster names and dependency details.
Scaling Configuration: Ensure the function dynamically retrieves scaling logic via tags to handle operational states.

5. Define the Workflow

Fetch Cluster Information: Use AWS APIs to retrieve cluster details, including their tags and states.
Check Dependencies:
- Identify dependent clusters and validate their status before initiating operations on others.
Start/Stop Clusters:
- Update node group configurations or use cluster-level start/stop APIs where supported.
Implement Logging and Alerts: Capture the execution details and errors in CloudWatch Logs.

(If you want my code , just comment "ease-py-code" on my blog , will share you 🫶 )

6. Test and Validate

Dry Runs: Perform simulations to ensure the function executes as expected without making actual changes.
Dependency Scenarios: Test different scenarios involving dependencies to validate the logic.
Error Handling: Verify retries and exception handling for potential API failures.

7. Deploy and Monitor

Deploy the Function: Once validated, deploy the Lambda function in the desired region.
Set Up Monitoring:
- Use CloudWatch Metrics to monitor function executions and errors.
- Configure alarms for failure scenarios to take corrective actions.

By automating the start and stop operations for EKS clusters, organizations can significantly enhance resource management and optimize costs. This approach provides scalability and ensures that inter-cluster dependencies are handled efficiently.

Follow for more and happy learning :)

How to Create a Lambda Function to Export IAM Users to S3 as a CSV File

Ragul.M — Mon, 16 Dec 2024 15:36:54 +0000

Managing AWS resources efficiently often requires automation. One common task is exporting a list of IAM users into a CSV file for auditing or reporting purposes. AWS Lambda is an excellent tool to achieve this, combined with the power of S3 for storage. Here's a step-by-step guide:

Step 1: Understand the Requirements
Before starting, ensure you have the following:

IAM permissions to list users (iam:ListUsers) and access S3 (s3:PutObject).
An existing S3 bucket to store the generated CSV file.
A basic understanding of AWS Lambda and its environment.

Step 2: Create an S3 Bucket

Log in to the AWS Management Console.
Navigate to S3 and create a new bucket or use an existing one.
Note the bucket name for use in the Lambda function.

Step 3: Set Up a Lambda Function

Go to the Lambda service in the AWS Console.
Click on Create Function and choose the option to create a function from scratch.
Configure the runtime environment (e.g., Python or Node.js).
Assign an appropriate IAM role to the Lambda function with permissions for IAM and S3 operations. (If you want my code , just comment "ease-py-code" on my blog , will share you 🫶 )

Step 4: Implement Logic for IAM and S3

The Lambda function will:
- Retrieve a list of IAM users using the AWS SDK.
- Format the list into a CSV structure.
- Upload the file to the specified S3 bucket.

Step 5: Test the Function

Use the AWS Lambda testing tools to trigger the function.
Verify that the CSV file is successfully uploaded to the S3 bucket.

Step 7: Monitor and Review

Check the S3 bucket for the uploaded CSV files.
Review the Lambda logs in CloudWatch to ensure the function runs successfully.

By following these steps, you can automate the task of exporting IAM user information into a CSV file and store it securely in S3, making it easier to track and manage your AWS users.

Follow for more and happy learning :)

Automating AWS Cost Management Reports with Lambda

Ragul.M — Wed, 11 Dec 2024 16:08:41 +0000

Monitoring AWS costs is essential for keeping budgets in check. In this guide, we’ll walk through creating an AWS Lambda function to retrieve cost details and send them to email (via SES) and Slack.
Prerequisites
1.AWS Account with IAM permissions for Lambda, SES, and Cost Explorer.
2.Slack Webhook URL to send messages.
3.Configured SES Email for notifications.
4.S3 Bucket for storing cost reports as CSV files.

Step 1: Enable Cost Explorer

Go to AWS Billing Dashboard > Cost Explorer.
Enable Cost Explorer to access detailed cost data.

Step 2: Create an S3 Bucket

Create an S3 bucket (e.g., aws-cost-reports) to store cost reports.
Ensure the bucket has appropriate read/write permissions for Lambda.

Step 3: Write the Lambda Code
1.Create a Lambda Function

Go to AWS Lambda > Create Function.
Select Python Runtime (e.g., Python 3.9).
1. Add Dependencies
Use a Lambda layer or package libraries like boto3 and slack_sdk. 3.Write your python code and execute them. (If you want my code , just comment "ease-py-code" on my blog , will share you 🫶 )

Step 4: Add S3 Permissions
Update the Lambda execution role to allow s3:PutObject, ses:SendEmail, and ce:GetCostAndUsage.

Step 5: Test the Lambda
1.Trigger Lambda manually using a test event.

Verify the cost report is:
- Uploaded to the S3 bucket.
- Emailed via SES.
- Notified in Slack.

Conclusion
With this setup, AWS cost reports are automatically delivered to your inbox and Slack, keeping you updated on spending trends. Fine-tune this solution by customizing the report frequency or grouping costs by other dimensions.

Follow for more and happy learning :)

Exploring Kubernetes: A Step Ahead of Basics

Ragul.M — Tue, 10 Dec 2024 05:35:38 +0000

Kubernetes is a powerful platform that simplifies the management of containerized applications. If you’re familiar with the fundamentals, it’s time to take a step further and explore intermediate concepts that enhance your ability to manage and optimize Kubernetes clusters.

Understanding Deployments
A Deployment ensures your application runs reliably by managing scaling, updates, and rollbacks.
Using ConfigMaps and Secrets
Kubernetes separates application configuration and sensitive data from the application code using ConfigMaps and Secrets.

ConfigMaps

Store non-sensitive configurations, such as environment variables or application settings.

kubectl create configmap app-config --from-literal=ENV=production

3. Liveness and Readiness Probes

Probes ensure your application is healthy and ready to handle traffic.

Liveness Probe
Checks if your application is running. If it fails, Kubernetes restarts the pod.

Readiness Probe
Checks if your application is ready to accept traffic. If it fails, Kubernetes stops routing requests to the pod.

4.Resource Requests and Limits
To ensure efficient resource utilization, define requests (minimum resources a pod needs) and limits (maximum resources a pod can use).

5.Horizontal Pod Autoscaling (HPA)
Scale your application dynamically based on CPU or memory usage.
Example:

kubectl autoscale deployment my-app --cpu-percent=70 --min=2 --max=10

This ensures your application scales automatically when resource usage increases or decreases.

6.Network Policies
Control how pods communicate with each other and external resources using Network Policies.

Conclusion
Kubernetes has revolutionized the way we manage containerized applications. By automating tasks like deployment, scaling, and maintenance, it allows developers and organizations to focus on innovation. Whether you're a beginner or a seasoned developer, mastering Kubernetes is a skill that will enhance your ability to build and manage modern applications.

By mastering these slightly advanced Kubernetes concepts, you’ll improve your cluster management, application reliability, and resource utilization. With this knowledge, you’re well-prepared to dive into more advanced topics like Helm, monitoring with Prometheus, and service meshes like Istio.

Follow for more and Happy learning :)

Understanding Kubernetes Basics: A Beginner’s Guide

Ragul.M — Fri, 29 Nov 2024 17:12:38 +0000

In today’s tech-driven world, Kubernetes has emerged as one of the most powerful tools for container orchestration. Whether you’re managing a few containers or thousands of them, Kubernetes simplifies the process, ensuring high availability, scalability, and efficient resource utilization. This blog will guide you through the basics of Kubernetes, helping you understand its core components and functionality.

What is Kubernetes?
Kubernetes, often abbreviated as K8s, is an open-source platform developed by Google that automates the deployment, scaling, and management of containerized applications. It was later donated to the Cloud Native Computing Foundation (CNCF).
With Kubernetes, developers can focus on building applications, while Kubernetes takes care of managing their deployment and runtime.

Key Features of Kubernetes

Automated Deployment and Scaling Kubernetes automates the deployment of containers and can scale them up or down based on demand.
Self-Healing If a container fails, Kubernetes replaces it automatically, ensuring minimal downtime.
Load Balancing Distributes traffic evenly across containers, optimizing performance and preventing overload.
Rollbacks and Updates Kubernetes manages seamless updates and rollbacks for your applications without disrupting service.
Resource Management Optimizes hardware utilization by efficiently scheduling containers across the cluster.

Core Components of Kubernetes
To understand Kubernetes, let’s break it down into its core components:

Cluster A Kubernetes cluster consists of:
Master Node: The control plane managing the entire cluster.
Worker Nodes: Machines where containers run.
Pods :The smallest deployable unit in Kubernetes. A pod can contain one or more containers that share resources like storage and networking.
Nodes : Physical or virtual machines that run the pods. Managed by the Kubelet, a process ensuring pods are running as expected.
Services : Allow communication between pods and other resources, both inside and outside the cluster. Examples include ClusterIP, NodePort, and LoadBalancer services.
ConfigMaps and Secrets : ConfigMaps: Store configuration data for your applications. Secrets: Store sensitive data like passwords and tokens securely.
Namespaces Virtual clusters within a Kubernetes cluster, used for organizing and isolating resources.

Conclusion
Kubernetes has revolutionized the way we manage containerized applications. By automating tasks like deployment, scaling, and maintenance, it allows developers and organizations to focus on innovation. Whether you're a beginner or a seasoned developer, mastering Kubernetes is a skill that will enhance your ability to build and manage modern applications.

Follow for more and Happy learning :)

Deep Dive into AWS

Ragul.M — Tue, 26 Nov 2024 13:50:21 +0000

Hi folks , welcome to my blog. Here we are going to see about some interesting deep topics in AWS.

What is AWS?

AWS is a subsidiary of Amazon that offers on-demand cloud computing services. These services eliminate the need for physical infrastructure, allowing businesses to rent computing power, storage, and other resources as needed. AWS operates on a pay-as-you-go model, which means you only pay for what you use.

Deep Dive: Serverless Architecture

One of AWS’s most revolutionary offerings is serverless computing. Traditional servers are replaced with fully managed services, allowing developers to focus solely on writing code.

Key Components of Serverless Architecture:

AWS Lambda: Automatically scales based on the number of requests. Ideal for microservices and event-driven workflows.
API Gateway: Connects client applications with backend services using APIs.
DynamoDB: High-performance NoSQL database for low-latency reads and writes.
EventBridge: Orchestrates serverless workflows using event-driven triggers. Example Use Case: Build a RESTful API without managing servers. Combine Lambda for compute, DynamoDB for storage, and API Gateway for routing.

Advanced Concepts in AWS

1. Elasticity and Auto-Scaling

AWS Auto Scaling monitors your application and adjusts capacity automatically to maintain performance. For example, if traffic spikes, AWS can add more EC2 instances or scale down when traffic reduces.

2. Hybrid Cloud and Outposts

Hybrid cloud models integrate on-premises infrastructure with AWS. AWS Outposts allow you to run AWS services on your own hardware, enabling low-latency solutions for specific industries.

3. High Availability and Disaster Recovery

AWS provides tools like:

Route 53 for DNS failover.
Cross-Region Replication for S3.
AWS Backup for centralized backup management across multiple services.

4. Monitoring and Logging

CloudWatch: Collect and monitor logs, metrics, and events.
CloudTrail: Records all API calls for auditing purposes.
AWS Config: Tracks changes to your resources for compliance.

Conclusion

AWS empowers organizations to innovate faster by providing scalable, secure, and cost-effective solutions. Whether you’re deploying a simple static website or a complex AI-powered application, AWS has the tools to support your goals. By leveraging its services and following best practices, you can build resilient and future-ready applications.

Follow for more and happy learning :)

Introduction to AWS

Ragul.M — Wed, 20 Nov 2024 16:13:29 +0000

Hi folks , welcome to my blog. Here we are going to see about "Introduction to AWS".

Amazon Web Services (AWS) is the world’s leading cloud computing platform, offering a wide range of services to help businesses scale and innovate. Whether you're building an application, hosting a website, or storing data, AWS provides reliable and cost-effective solutions for individuals and organizations of all sizes.

What is AWS?
AWS is a comprehensive cloud computing platform provided by Amazon. It offers on-demand resources such as compute power, storage, networking, and databases on a pay-as-you-go basis. This eliminates the need for businesses to invest in and maintain physical servers.

Core Benefits of AWS

Scalability: AWS allows you to scale your resources up or down based on your needs.
Cost-Effective: With its pay-as-you-go pricing, you only pay for what you use.
Global Availability: AWS has data centers worldwide, ensuring low latency and high availability.
Security: AWS follows a shared responsibility model, offering top-notch security features like encryption and access control.
Flexibility: Supports multiple programming languages, operating systems, and architectures.

Key AWS Services
Here are some of the most widely used AWS services:

Compute:
- Amazon EC2: Virtual servers to run your applications.
- AWS Lambda: Serverless computing to run code without managing servers.
Storage:
- Amazon S3: Object storage for data backup and distribution.
- Amazon EBS: Block storage for EC2 instances.
Database:
- Amazon RDS: Managed relational databases like MySQL, PostgreSQL, and Oracle.
- Amazon DynamoDB: NoSQL database for high-performance applications.
Networking:
- Amazon VPC: Create isolated networks in the cloud.
- Amazon Route 53: Domain name system (DNS) and traffic management.
AI/ML:
- Amazon SageMaker: Build, train, and deploy machine learning models.
DevOps Tools:
- AWS CodePipeline: Automates the release process.
- Amazon EKS: Managed Kubernetes service.

Conclusion
AWS has revolutionized the way businesses leverage technology by providing scalable, secure, and flexible cloud solutions. Whether you're a developer, an enterprise, or an enthusiast, understanding AWS basics is the first step toward mastering the cloud. Start your AWS journey today and unlock endless possibilities!

Follow for more and happy learning :)

Basic Linux Commands

Ragul.M — Fri, 15 Nov 2024 14:25:50 +0000

Hi folks , welcome to my blog. Here we are going to see some basic and important commands of linux.

One of the most distinctive features of Linux is its command-line interface (CLI). Knowing a few basic commands can unlock many possibilities in Linux.
Essential Commands
Here are some fundamental commands to get you started:
ls - Lists files and directories in the current directory.

cd - Changes to a different directory.

cd /home/user/Documents

pwd - Prints the current working directory.

pwd

cp - Copies files or directories.

cp file1.txt /home/user/backup/

mv - Moves or renames files or directories.

mv file1.txt file2.txt

rm - Removes files or directories.

rm file1.txt

mkdir - Creates a new directory.

mkdir new_folder

touch - Creates a new empty file.

touch newfile.txt

cat - Displays the contents of a file.

cat file1.txt

nano or vim - Opens a file in the text editor.

nano file1.txt

chmod - Changes file permissions.

chmod 755 file1.txt

ps - Displays active processes.

kill - Terminates a process.

kill [PID]

Each command is powerful on its own, and combining them enables you to manage your files and system effectively.We can see more about some basics and interesting things about linux in further upcoming blogs which I will be posting.

Follow for more and happy learning :)

Linux basics for beginners

Ragul.M — Thu, 14 Nov 2024 16:04:04 +0000

Introduction:
Linux is one of the most powerful and widely-used operating systems in the world, found everywhere from mobile devices to high-powered servers. Known for its stability, security, and open-source nature, Linux is an essential skill for anyone interested in IT, programming, or system administration.
In this blog , we are going to see What is linux and Why choose linux.

1) What is linux
Linux is an open-source operating system that was first introduced by Linus Torvalds in 1991. Built on a Unix-based foundation, Linux is community-driven, meaning anyone can view, modify, and contribute to its code. This collaborative approach has led to the creation of various Linux distributions, or "distros," each tailored to different types of users and use cases. Some of the most popular Linux distributions are:

Ubuntu: Known for its user-friendly interface, great for beginners.
Fedora: A cutting-edge distro with the latest software versions, popular with developers.
CentOS: Stable and widely used in enterprise environments. Each distribution may look and function slightly differently, but they all share the same core Linux features.

2) Why choose linux
Linux is favored for many reasons, including its:

Stability: Linux is well-known for running smoothly without crashing, even in demanding environments.
Security: Its open-source nature allows the community to detect and fix vulnerabilities quickly, making it highly secure.
Customizability: Users have complete control to modify and customize their system.
Performance: Linux is efficient, allowing it to run on a wide range of devices, from servers to small IoT devices.

Conclusion
Learning Linux basics is the first step to becoming proficient in an operating system that powers much of the digital world. We can see more about some basics and interesting things about linux in further upcoming blogs which I will be posting.

Follow for more and happy learning :)

DEV Community: Ragul.M

Setting Up Kubernetes and Nginx Ingress Controller on an EC2 Instance

Introduction

Deploying a Two-Tier Web Application on AWS with MySQL and Apache

Deploying a Scalable AWS Infrastructure with VPC, ALB, and Target Groups Using Terraform

Managing EKS Clusters Using AWS Lambda: A Step-by-Step Approach

How to Create a Lambda Function to Export IAM Users to S3 as a CSV File

Automating AWS Cost Management Reports with Lambda

Exploring Kubernetes: A Step Ahead of Basics

ConfigMaps

3. Liveness and Readiness Probes

Understanding Kubernetes Basics: A Beginner’s Guide

Deep Dive into AWS

What is AWS?

Deep Dive: Serverless Architecture

Key Components of Serverless Architecture:

Advanced Concepts in AWS

1. Elasticity and Auto-Scaling

2. Hybrid Cloud and Outposts

3. High Availability and Disaster Recovery

4. Monitoring and Logging

Conclusion

Introduction to AWS

Basic Linux Commands

Linux basics for beginners