Forem: HARI SARAVANAN

AWS SERVICES SPOTLIGHT : CLOUDHSM (HARDWARD SECURITY MODULE)

HARI SARAVANAN — Thu, 18 Dec 2025 14:49:46 +0000

SERVICE OVERVIEW:

AWS CloudHSM is a cloud-based Hardware Security Module (HSM) service that enables organizations to generate, store, and manage cryptographic keys inside tamper-resistant hardware.
It helps meet strict security, compliance, and regulatory requirements by ensuring full control over encryption keys.

KEY-FEATURES:

Dedicated HSM instances (single-tenant)
FIPS 140-2 Level 3 compliant security
Secure key generation, storage, and management
Full customer control over encryption keys
Supports industry-standard APIs (PKCS#11, JCE, OpenSSL)
High availability using HSM clusters

AWS CATEGORY/CLOUD DOMAIN:

Security, Identity & Compliance

WHERE IT FITS IN CLOUD/DEVOPS LIFECYCLE:

AWS CloudHSM fits into the Security & Compliance phase of the Cloud and DevSecOps lifecycle.

In DevSecOps pipelines, CloudHSM is used for:
Secure key management for encryption & decryption
Digital signing of code and certificates
Protecting sensitive data in databases, applications, and containers
Meeting compliance requirements (PCI-DSS, HIPAA, financial regulations)

📌 CloudHSM ensures security is embedded, not added later.

PROGRAMMING LANGUAGE/ACCESS METHOD:

AWS CloudHSM is accessed using:
PKCS#11
Java Cryptography Extensions (JCE)
OpenSSL
AWS SDKs and CLI for management
Supported languages include:
Java
Python
C / C++

PRICING MODEL:

AWS CloudHSM follows a pay-as-you-go pricing model:

Charged per HSM instance per hour
Additional costs for backup and data transfer
No upfront commitments

📌 Ideal for enterprises that need maximum security with flexible scaling.

WHYCLOUDHSM MTTER IN DEVOPS:

“If your keys are compromised, your security is compromised.”

CloudHSM provides:

Strong cryptographic isolation
Customer-owned key control
Hardware-level trust for cloud workloads

DEVOPS PERIODIC TABLE AND RULES HT: HASHICORP TERRAFORM

HARI SARAVANAN — Thu, 18 Dec 2025 14:28:51 +0000

HASHICORP TERRAFORM

OVERVIEW OF THE TOOL:
HashiCorp Terraform is an Infrastructure as Code (IaC) tool that allows developers and DevOps engineers to define, provision, and manage cloud infrastructure using code.
It enables consistent, repeatable, and automated infrastructure deployment across multiple cloud providers.

Terraform treats infrastructure the same way developers treat application code — versioned, reviewed, and automated.

KEY-FEATURES:

Infrastructure as Code (IaC) using declarative configuration files
Multi-cloud support (AWS, Azure, GCP, Kubernetes, etc.)
Execution plans to preview infrastructure changes before applying
State management to track real-world infrastructure
Reusable modules for standard and scalable infrastructure design
Strong ecosystem with thousands of providers and plugins

HOW IT FIT INTO DEVOPS/DEVSECOPS:

Terraform fits into the Infrastructure Provisioning stage of the DevOps and DevSecOps lifecycle.
In a DevSecOps pipeline, Terraform helps by:
Enforcing secure-by-default infrastructure
Enabling policy-as-code (with tools like Sentinel)
Reducing human errors through automation
Integrating seamlessly with CI/CD pipelines (Jenkins, GitHub Actions, GitLab CI)

📌 In short: Terraform builds the foundation on which secure applications run.

PROGRAMMING LANGUAGE:

Terraform uses HCL (HashiCorp Configuration Language), a declarative language designed to be:
Human-readable
Easy to learn
Machine-friendly

Terraform also supports JSON syntax and can be integrated using SDKs and APIs

PARENT COMPANY:

Terraform is developed and maintained by HashiCorp, a company specializing in cloud infrastructure automation tools.

OPENSOURCE OR PAID?

Terraform Core → ✅ Open Source
Terraform Enterprise / Terraform Cloud → 💰 Paid (with free tier)

This allows individuals and startups to start free and scale with enterprise-grade features later

MONGODB IN ACTION : BUILDING A SMART STUDENT DATABASE WITH CRUD OPERATIONS

HARI SARAVANAN — Thu, 06 Nov 2025 13:45:05 +0000

🧩 Short Introduction (for your blog / LinkedIn post)
📘 Introduction

In this task, I explored how to perform CRUD operations (Create, Read, Update, Delete) using MongoDB, a popular NoSQL database that stores data in JSON-like documents.

MongoDB is flexible and schema-less, making it perfect for applications where data structure can evolve over time.
To understand how it works, I created a simple students collection to manage college student records, and performed all CRUD operations step-by-step.
🏗️ Step 1: Create Collection & Insert Documents
db.students.insertMany([
{ "student_id": "S001", "name": "Santhosh", "age": 20, "department": "CSBS", "year": 2, "cgpa": 9.0 },
{ "student_id": "S002", "name": "Priya", "age": 21, "department": "IT", "year": 3, "cgpa": 8.7 },
{ "student_id": "S003", "name": "Ravi", "age": 22, "department": "ECE", "year": 4, "cgpa": 7.3 },
{ "student_id": "S004", "name": "Meena", "age": 19, "department": "CSBS", "year": 1, "cgpa": 9.2 },
{ "student_id": "S005", "name": "Vikram", "age": 20, "department": "MECH", "year": 2, "cgpa": 8.1 }
]);

🔍 Step 2: Read (Query) Operations

a) Display all student records

db.students.find();

b) Find all students with CGPA > 8

db.students.find({ cgpa: { $gt: 8 } });

c) Find all students from the "CSBS" department

db.students.find({ department: "CSBS" });

✏️ Step 3: Update Operations

a) Update the CGPA of a specific student (say, S002)

db.students.updateOne(
{ student_id: "S002" },
{ $set: { cgpa: 9.1 } }
);

b) Increase the year of all 3rd year students by 1

db.students.updateMany(
{ year: 3 },
{ $inc: { year: 1 } }
);

🗑️ Step 4: Delete Operations

a) Delete one student by ID

db.students.deleteOne({ student_id: "S003" });

b) Delete all students with CGPA < 7.5

db.students.deleteMany({ cgpa: { $lt: 7.5 } });

📤 Step 5: Export Final Collection

Export as JSON:

mongoexport --uri="your_connection_URI" --collection=students --out=students.json

Export as CSV:

mongoexport --uri="your_connection_URI" --collection=students --type=csv --fields=student_id,name

💡 Introduction

(Use the short intro above)

🏗️ Creating the Database & Collection

(Code + screenshot)

✨ Insert (Create Operation)

(Code + screenshot)

🔍 Read (Query Operation)

(Code + screenshots for all queries)

✏️ Update Operation

(Code + before/after screenshots)

🗑️ Delete Operation

(Code + before/after screenshots)

📤 Exporting Data

(Show final JSON/CSV file)

🏁 Conclusion

CRUD operations in MongoDB are simple yet powerful.
They form the foundation of most modern NoSQL-based applications.

DATABASE NORMALIZATION IN SQL - 1NF,2NF AND 3NF EXPLAINED (STUDENT - COURSE CASE STUDY

HARI SARAVANAN — Thu, 06 Nov 2025 12:22:50 +0000

📘 Introduction

Database Normalization is the process of organizing data in a database to reduce redundancy and avoid data anomalies (insertion, update, and deletion problems).

It divides a large, unorganized table into smaller, related tables — ensuring data consistency and integrity.

The most common normal forms are:

1NF (First Normal Form): Remove repeating groups and ensure each cell holds a single value.

2NF (Second Normal Form): Remove partial dependency — every non-key attribute depends on the whole primary key.

3NF (Third Normal Form): Remove transitive dependency — non-key attributes should not depend on other non-key attributes.

Normalization makes your database cleaner, faster, and easier to maintain.

⚠️ Step 1: Identify Anomalies

Insertion Anomaly: Can’t insert a new course unless a student takes it.
Update Anomaly: If an instructor changes name, you must update multiple rows.
Deletion Anomaly: If Alice drops a course, you might lose information about that course’s instructor

✅ Step 2: Convert to 1NF (First Normal Form)

👉 Rule: Remove repeating groups — each column must have atomic (single) values.

The table already satisfies 1NF since all columns have atomic values.
Let’s write the SQL:

✅ Step 3: Convert to 2NF (Second Normal Form)

👉 Rule: Remove partial dependency — every non-key attribute must depend on the entire primary key.

Here, the composite key is (StudentID, CourseID).
But StudentName depends only on StudentID, and CourseName and InstructorName depend only on CourseID.

So we split the table into three:

1️⃣ Students
CREATE TABLE Students (
StudentID INT PRIMARY KEY,
StudentName VARCHAR(50)
);

2️⃣ Courses
CREATE TABLE Courses (
CourseID VARCHAR(10) PRIMARY KEY,
CourseName VARCHAR(50),
InstructorName VARCHAR(50)
);

3️⃣ Enrollments
CREATE TABLE Enrollments (
StudentID INT,
CourseID VARCHAR(10),
PRIMARY KEY (StudentID, CourseID)
);

✅ Step 4: Convert to 3NF (Third Normal Form)

👉 Rule: Remove transitive dependency — non-key columns shouldn’t depend on other non-key columns.

In Courses, InstructorName depends on CourseID (which is fine), but if one instructor teaches multiple courses, that’s repetition.
So we create a separate Instructors table.

1️⃣ Instructors
CREATE TABLE Instructors (
InstructorID INT PRIMARY KEY,
InstructorName VARCHAR(50)
);

2️⃣ Update Courses to include a foreign key
CREATE TABLE Courses_3NF (
CourseID VARCHAR(10) PRIMARY KEY,
CourseName VARCHAR(50),
InstructorID INT,
FOREIGN KEY (InstructorID) REFERENCES Instructors(InstructorID)
);

3️⃣ Students and Enrollments remain same
CREATE TABLE Students_3NF (
StudentID INT PRIMARY KEY,
StudentName VARCHAR(50)
);

CREATE TABLE Enrollments_3NF (
StudentID INT,
CourseID VARCHAR(10),
PRIMARY KEY (StudentID, CourseID),
FOREIGN KEY (StudentID) REFERENCES Students_3NF(StudentID),
FOREIGN KEY (CourseID) REFERENCES Courses_3NF(CourseID)
);

✅ Step 5: Insert Sample Data
INSERT INTO Instructors VALUES
(1, 'Dr. Kumar'),
(2, 'Dr. Meena'),
(3, 'Dr. Ravi');

INSERT INTO Courses_3NF VALUES
('C101', 'DBMS', 1),
('C102', 'OS', 2),
('C103', 'Networks', 3);

INSERT INTO Students_3NF VALUES
(1, 'Alice'),
(2, 'Bob'),
(3, 'Charlie');

INSERT INTO Enrollments_3NF VALUES
(1, 'C101'),
(2, 'C102'),
(1, 'C102'),
(3, 'C103');

✅ Step 6: Query to List All Students with Courses and Instructors
SELECT s.StudentName, c.CourseName, i.InstructorName
FROM Enrollments_3NF e
JOIN Students_3NF s ON e.StudentID = s.StudentID
JOIN Courses_3NF c ON e.CourseID = c.CourseID
JOIN Instructors i ON c.InstructorID = i.InstructorID;

💡 Introduction

(Use the short intro above)

⚙️ Base Table & Anomalies

(Show sample table + insertion/update/deletion anomalies)

🧱 1NF

(Code + screenshot)

🔗 2NF

(Code + screenshots of separate tables)

🌿 3NF

(Code + screenshots of normalized tables)

🧮 Final JOIN Query

(Show combined result table)

🏁 Conclusion

Normalization removes redundancy, ensures data consistency, and improves data integrity.

INDEXING,HASHING & QUERY OPTIMIZATION IN SQL (EXAMPLE ON STUDENTS TABLE )

HARI SARAVANAN — Thu, 06 Nov 2025 12:07:50 +0000

📘 Introduction

In databases, indexing and hashing are techniques used to improve the speed of data retrieval operations. Without indexes, the database must scan every row to find a match, which is slow for large tables.

B-Tree Index: Used for range and equality queries (e.g., searching roll numbers or CGPAs).

B+ Tree Index: A variation of B-Tree that stores data only in leaf nodes, providing faster sequential access.

Hash Index: Used for exact match lookups (e.g., searching by department name).

Query Optimization ensures that the database uses the most efficient way to execute SQL queries — often by choosing the right index.

Step 1: Create Table
CREATE TABLE Students (
roll_no INT PRIMARY KEY,
name VARCHAR(50),
dept VARCHAR(10),
cgpa DECIMAL(3,2)
);

Step 2: Insert 20 Sample Records

Step 3: Create B-Tree Index on
EXPLAIN SELECT * FROM Students WHERE roll_no = 110;

Step 4: Fetch details of student with roll_no = 110
EXPLAIN SELECT * FROM Students WHERE roll_no = 110;

✅ The EXPLAIN keyword shows how the query uses the index

Step 5: Create B+ Tree Index on cgpa

In MySQL, normal indexes use B+ Tree structure internally.
So the syntax is the same:

CREATE INDEX idx_cgpa ON Students(cgpa);

Then query:

EXPLAIN SELECT * FROM Students WHERE cgpa > 8.0;

Step 6: Create Hash Index on dept

⚠️ Note: MySQL supports Hash Index only on MEMORY (HEAP) tables, or in PostgreSQL using USING HASH.

✅ For MySQL:
CREATE INDEX idx_dept USING HASH ON Students(dept);

✅ For PostgreSQL:
CREATE INDEX idx_dept_hash ON Students USING HASH (dept);

Step 7: Retrieve students from ‘CSBS’ department
EXPLAIN SELECT * FROM Students WHERE dept = 'CSBS';

💡 Introduction

Explain indexing, hashing, and optimization (use the intro above).

🧱 Table Creation and Data Insertion

(Include screenshot of all students.)

🌳 B-Tree Index on Roll Number

(Include query + EXPLAIN screenshot.)

🌲 B+ Tree Index on CGPA

(Show query + EXPLAIN output for cgpa > 8.0.)

🧩 Hash Index on Department

(Show query + EXPLAIN output for ‘CSBS’ department.)

⚙️ Query Optimization

Mention how indexes reduce the time for searching records.

🏁 Conclusion

Indexes and hashing make data retrieval much faster and efficient by avoiding full table scans.

THE BACKBONE OF DATABASE REALIABILITY: EXPLORING ACID IN ACTION WITH SQL TRANSACTION A STEP-STEP-STEP GUIDE

HARI SARAVANAN — Thu, 06 Nov 2025 11:10:36 +0000

In database systems, ACID stands for Atomicity, Consistency, Isolation, and Durability. These four key properties ensure that database transactions are processed reliably — even in the case of errors, system crashes, or multiple users accessing the same data at once.

A transaction is a single logical unit of work that can include one or more SQL operations (like INSERT, UPDATE, or DELETE).
For example, transferring money between two bank accounts involves deducting an amount from one account and adding it to another. Both actions must succeed together — or fail completely — to maintain correctness.

The ACID properties guarantee this reliability:

Atomicity: Ensures that all steps in a transaction are treated as one single “all or nothing” operation.

Consistency: Ensures that the database remains in a valid state before and after the transaction.

Isolation: Ensures that transactions occurring at the same time do not interfere with each other.

Durability: Ensures that once a transaction is committed, its changes are permanent, even after a system crash.

Together, these properties form the foundation of trustworthy database systems, keeping your data accurate and secure.

CREATE TABLE Accounts (
acc_no INT PRIMARY KEY,
name VARCHAR(50),
balance INT CHECK (balance >= 0)
);

INSERT INTO Accounts VALUES
(101, 'Alice', 1000),
(102, 'Bob', 800),
(103, 'Charlie', 1200);

⚙️ Step 2: Demonstrate Atomicity

Goal: Show that a failed transaction rolls back — no partial update remains
-- Start Transaction
START TRANSACTION;

-- Alice sends 500 to Bob
UPDATE Accounts SET balance = balance - 500 WHERE acc_no = 101;

-- Bob receives 500
UPDATE Accounts SET balance = balance + 500 WHERE acc_no = 102;

-- Simulate an error or rollback
ROLLBACK;

-- Check balances again
SELECT * FROM Accounts;

Explanation:
After rollback, balances of Alice and Bob should remain the same (1000 and 800).
That shows Atomicity — either all steps complete or none do.

Step 3: Demonstrate Consistency

Goal: Database rules prevent invalid data.

Try to insert a record with a negative balance:

INSERT INTO Accounts VALUES (104, 'David', -500);

Step 4: Demonstrate Isolation

Goal: Two sessions should not interfere.
START TRANSACTION;
UPDATE Accounts SET balance = balance + 1000 WHERE acc_no = 101;

2️⃣ Session 2 (in another SQL tab/window)
SELECT * FROM Accounts WHERE acc_no = 101;

💾 Step 5: Demonstrate Durability

Goal: Data persists even after DB restart.

START TRANSACTION;
UPDATE Accounts SET balance = balance + 200 WHERE acc_no = 103;
COMMIT;

Conclusion:
This experiment shows how ACID ensures reliability in SQL transactions — no data loss, corruption, or interference.

Transactions,Deadlocks & Log Based Recovery

HARI SARAVANAN — Thu, 09 Oct 2025 07:25:38 +0000

1.Transaction, Atomicity, and Rollback

A transaction is a sequence of operations performed as a single logical unit of work.
Atomicity means either all operations complete successfully, or none do (if something fails or you rollback).
Rollback means to undo all operations in the transaction if it is not committed.

2.Deadlocks

Deadlocks happen when two transactions each hold locks on resources the other needs, and neither can proceed, causing a standstill.

3.Log-Based Recovery

Databases keep logs of all transactions.
These logs help undo (rollback) or redo operations if needed, ensuring data consistency and recovery after crashes.

Step 1: Setup Your Environment with the Accounts Table
Create the table:

sql
CREATE TABLE Accounts (
acc_no INT PRIMARY KEY,
name VARCHAR(50),
balance INT
);

Insert initial data:

sql
INSERT INTO Accounts VALUES
(1, 'Alice', 1000),
(2, 'Bob', 1500),
(3, 'Charlie', 2000);

initial table

Step 2: Transaction – Atomicity & Rollback
Start a transaction.

Transfer 500 from Alice (acc_no=1) to Bob (acc_no=2).

Before committing, rollback the transaction.

Check balances to confirm no partial update (Alice and Bob's balances unchanged).

BEGIN TRANSACTION;

UPDATE Accounts SET balance = balance - 500 WHERE acc_no = 1;
UPDATE Accounts SET balance = balance + 500 WHERE acc_no = 2;

ROLLBACK;

SELECT * FROM Accounts;

Step 3: Deadlock Simulation
You need two separate database sessions (tools like MySQL Workbench or psql can open multiple connections).

Session 1:
BEGIN;
SELECT * FROM Accounts WHERE acc_no = 1 FOR UPDATE; -- lock Alice's account
UPDATE Accounts SET balance = balance + 100 WHERE acc_no = 2; -- try to update Bob's account
-- wait or hold here before committing

BEGIN;
SELECT * FROM Accounts WHERE acc_no = 2 FOR UPDATE; -- lock Bob's account
UPDATE Accounts SET balance = balance - 100 WHERE acc_no = 1; -- try to update Alice's account
-- observe deadlock happens here or waits indefinitely

Deadlock occurs because each session waits for the other to release their lock.

Step 4: Log-Based Recovery
Ensure logging is enabled in your database (default in MySQL binary log or PostgreSQL WAL).

Start a transaction to update a record.

Rollback the transaction.

Check the log files or use database tools to confirm the undo was logged.

Cursor And Trigger In DBMS

HARI SARAVANAN — Wed, 08 Oct 2025 14:05:13 +0000

Sql Database

Tutorial

STEP:1 Create A Sample Table
CREATE TABLE Employee (
emp_id NUMBER PRIMARY KEY,
emp_name VARCHAR2(50),
salary NUMBER
);

Step 2: Insert the Record
INSERT INTO Employee VALUES (1, 'John Doe', 60000);
INSERT INTO Employee VALUES (2, 'Jane Smith', 48000);
INSERT INTO Employee VALUES (3, 'Emily Davis', 52000);
COMMIT;

Step 3: Write A cursor Program
CREATE OR REPLACE TRIGGER trg_student_audit
AFTER INSERT ON Students
FOR EACH ROW
BEGIN
INSERT INTO Student_Audit (audit_id, student_id, action, log_time)
VALUES (student_audit_seq.NEXTVAL, :NEW.student_id, 'INSERT', SYSTIMESTAMP);
END;
/

TRIGGER EXAMPLES

Step 4: Create An Audit Table
CREATE TABLE Students (
student_id NUMBER PRIMARY KEY,
student_name VARCHAR2(50),
course VARCHAR2(30)
);

Step:5 Create A Trigger
CREATE TABLE Student_Audit (
audit_id NUMBER PRIMARY KEY,
student_id NUMBER,
action VARCHAR2(20),
log_time TIMESTAMP
);

Step 6: Test A Trigger
CREATE SEQUENCE student_audit_seq START WITH 1 INCREMENT BY 1;

Conclusion
This tutorial showed how to use a cursor to process conditional data and how to automate audit logging using an AFTER INSERT trigger in Oracle SQL. Try running these examples yourself on Oracle Live SQL, and customize the logic for your own applications!

College Student & Course Management System

HARI SARAVANAN — Mon, 25 Aug 2025 16:54:59 +0000

1️⃣ Creating the Students Table

I began by creating a Students table with fields for StudentID, StudentName, Dept, and Email.

StudentID → Primary Key

StudentName → NOT NULL

Email → UNIQUE

📸 Screenshot:

2️⃣ Inserting Student Records

Next, I inserted three students into the table, each from different departments.

📸 Screenshot:

3️⃣ Altering the Table – Adding PhoneNo

Later, I realized I needed a Phone Number column, so I used the ALTER TABLE command to add a new column that can store a 10-digit phone number.

📸 Screenshot:

4️⃣ Adding Constraints to Courses

To practice constraints, I tried modifying the Courses table so that Credits must be between 1 and 5.
👉 Since my Courses table didn’t exist yet, Oracle threw an error – a reminder to always create the table first!

📸 Screenshot:

5️⃣ Creating a View – StudentCoursesView

Finally, I wrote a query to join Students, Courses, and Enrollments and created a view named StudentCoursesView to display StudentName, CourseName, and Grade.

📸 Screenshot: