When I started learning cloud engineering, I believed infrastructure was mostly about launching servers and hosting applications.
In the past few days, that perspective has changed significantly.
On Day 3, I deployed a web application on a Linux server using Amazon EC2 and Nginx.
On Day 4, I hosted a static website using Amazon S3 without running a server at all.
Today’s learning introduced another important part of cloud architecture:
Databases and serverless computing.
I explored how applications store and process data using:
- Amazon RDS
- Amazon DynamoDB
- AWS Lambda
These services showed me how AWS enables developers to build scalable backend systems without managing infrastructure manually.
🚀 The Objective
Today’s goal was to understand how cloud applications manage and process data.
The focus areas were:
- Deploying a managed relational database
- Connecting an application server to the database
- Learning NoSQL database architecture
- Executing backend logic using serverless functions
This meant working with three important AWS services:
- Amazon RDS
- Amazon DynamoDB
- AWS Lambda
🗄️ Step 1: Understanding Amazon RDS
The first service I explored was Amazon RDS (Relational Database Service).
RDS is a managed database service that allows developers to run relational databases without handling server management tasks like:
- OS patching
- Backups
- High availability configuration
- Scaling
AWS takes care of the infrastructure while developers focus on applications.
Supported database engines include:
- MySQL
- PostgreSQL
- MariaDB
- Oracle Database
- Microsoft SQL Server
For practice, I created a MySQL RDS instance.
⚙️ Step 2: Launching an RDS Database
I created my first managed database instance using the AWS console.
Configuration included:
- Engine: MySQL
- Instance type: db.t3.micro (Free Tier eligible)
- Storage: 20 GB
- Region: Mumbai
- Public accessibility: enabled for testing
After the instance was created, AWS automatically provided a database endpoint.
This endpoint acts like the database address that applications use to connect.
Example structure:
mydb.xxxxxx.ap-south-1.rds.amazonaws.com
Instead of installing MySQL manually on a server, AWS handled the entire database infrastructure.
🔗 Step 3: Connecting EC2 to RDS
Next, I connected my Amazon EC2 instance to the RDS database.
The connection required proper network and security configuration.
Steps included:
- Allowing inbound database access in security groups
- Using the RDS endpoint
- Connecting via MySQL client from the EC2 server
Once connected, I was able to:
- Create databases
- Create tables
- Insert and retrieve data
This demonstrated how application servers interact with managed databases in real-world cloud architectures.
🧩 Step 4: Understanding DynamoDB (NoSQL)
After working with relational databases, I explored Amazon DynamoDB.
DynamoDB is a fully managed NoSQL database designed for high scalability and low latency.
Unlike relational databases, DynamoDB stores data in:
- Tables
- Items
- Attributes
Example structure:
Users Table
├── UserID
├── Name
├── Email
└── CreatedDate
Key advantages of DynamoDB include:
- Automatic scaling
- Millisecond latency
- Serverless architecture
- Fully managed infrastructure
This makes DynamoDB ideal for modern cloud applications such as:
- mobile apps
- gaming backends
- real-time analytics
- serverless architectures
⚡ Step 5: Running Serverless Code with AWS Lambda
Next, I explored AWS Lambda.
Lambda allows developers to run code without managing servers.
Instead of deploying applications on EC2, Lambda executes code only when triggered.
Common triggers include:
- API requests
- file uploads
- database events
- scheduled tasks
For practice, I created a Lambda function that interacted with DynamoDB.
The workflow looked like this:
Client Request
↓
AWS Lambda Function
↓
DynamoDB Table
↓
Response Returned
This architecture is known as serverless backend architecture.
The biggest advantage is that AWS automatically handles:
- infrastructure
- scaling
- execution environment
Developers only focus on writing code.
🧠 Key Technical Takeaways
Today’s learning introduced important backend architecture concepts:
- How Amazon RDS provides managed relational databases
- How EC2 applications communicate with RDS
- The difference between SQL and NoSQL databases
- How Amazon DynamoDB handles high-scale workloads
- How AWS Lambda runs backend code without servers
- How serverless architecture simplifies infrastructure management
One key realization stood out:
Cloud platforms allow developers to choose between multiple architectures depending on the application’s needs.
🎯 Reflection
In just a few days of learning cloud engineering, I’ve experienced several different deployment models:
Day 3
Application deployed on Amazon EC2 using Nginx
Day 4
Static website hosted using Amazon S3
Day 5
Backend architecture using Amazon RDS, Amazon DynamoDB, and AWS Lambda
Each approach solves a different type of problem.
Traditional servers provide full control.
Object storage enables lightweight hosting.
Serverless services enable scalable backend architectures.
Understanding when to use each of these approaches is what makes cloud engineering powerful.
This is Day 5 of my cloud learning journey, and every day the architecture possibilities are becoming clearer.
More exploration ahead. 🚀
Top comments (0)