From AWS Fundamentals to DevOps: My Practical Cloud Learning Journey
Cloud computing has become an important part of modern software development and IT infrastructure. Among the major cloud platforms, Amazon Web Services (AWS) provides a wide range of services for computing, storage, networking, security, databases, containers, monitoring, and automation.
From AWS Fundamentals to DevOps: My Practical Cloud Learning Journey
Introduction
Cloud computing has become an important part of modern software development and IT infrastructure. Among the major cloud platforms, Amazon Web Services (AWS) provides a wide range of services for computing, storage, networking, security, databases, containers, monitoring, and automation.
As I started learning DevOps, I realized that understanding AWS is not only about memorizing services. The more important part is learning how different AWS services work together to deploy, operate, monitor, and scale applications.
In this article, I’ll share my learning journey from AWS fundamentals toward practical DevOps and cloud engineering.
1. Understanding Cloud Computing
Before working with AWS, I started by understanding the basic idea of cloud computing.
Instead of purchasing and maintaining physical servers, organizations can use cloud resources when they need them.
Some important benefits include:
- On-demand infrastructure
- Scalability
- High availability
- Global infrastructure
- Pay-as-you-go pricing
- Reduced infrastructure management
AWS provides these capabilities through many different services.
2. Learning Amazon EC2
One of the first AWS services I practiced was Amazon EC2 (Elastic Compute Cloud).
EC2 provides virtual servers that can be used to run applications.
While working with EC2, I learned about:
- AMIs
- Instance types
- Key pairs
- Security groups
- EBS volumes
- Public and private IP addresses
- SSH connections
- User data
For example, a simple Linux-based EC2 instance can be used to host a web server.
A basic workflow looks like this:
1
2
3
4
5
6
7
8
9
10
11
12
13
Developer
|
v
AWS Console / AWS CLI
|
v
EC2 Instance
|
v
Linux Server
|
v
Application
This helped me understand how a cloud server is different from a local machine.
3. Linux and AWS
Learning AWS also made me realize how important Linux is for DevOps.
After connecting to an EC2 instance, many tasks are performed using Linux commands.
For example:
1
2
3
4
sudo yum update -y
sudo yum install httpd -y
sudo systemctl start httpd
sudo systemctl enable httpd
These commands demonstrate a simple web-server setup.
Understanding Linux helps with:
- Server administration
- Application deployment
- Log analysis
- Process management
- File permissions
- Networking
- Troubleshooting
For anyone interested in DevOps, I believe Linux fundamentals are an important skill to develop alongside AWS.
4. Understanding IAM
Security is another important part of AWS.
AWS Identity and Access Management (IAM) allows us to control access to AWS resources.
While learning IAM, I focused on understanding:
- Users
- Groups
- Roles
- Policies
- Permissions
- Least-privilege access
For example, instead of giving a user full administrative access, we can create permissions that allow only the required actions.
This introduced me to an important DevOps principle:
Give systems and users only the permissions they actually need.
5. AWS Networking
Another major area of my AWS learning has been networking.
I started exploring concepts such as:
- VPC
- Subnets
- Route tables
- Internet Gateway
- NAT Gateway
- Security Groups
- Network ACLs
- Public and private subnets
A simplified architecture can look like:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Internet
|
v
+----------------+
| Internet |
| Gateway |
+----------------+
|
v
+----------------+
| Public Subnet |
| Load Balancer |
+----------------+
|
v
+----------------+
| Private Subnet |
| Application |
+----------------+
Understanding networking is especially useful when working with containers, Kubernetes, and production applications.
6. Working with Docker and Amazon ECR
After learning basic AWS services, I started connecting AWS with containerization.
Docker allows applications to be packaged with their dependencies into containers.
A typical workflow is:
1
2
3
4
5
6
7
8
9
10
11
12
13
Source Code
|
v
Dockerfile
|
v
Docker Image
|
v
Amazon ECR
|
v
AWS Compute Service
Amazon Elastic Container Registry (ECR) provides a place to store container images.
For example, after building an application image locally, it can be tagged and pushed to an ECR repository.
This creates a bridge between local Docker development and AWS-based deployment.
7. Kubernetes and Amazon EKS
As I continued learning DevOps, I started exploring Kubernetes.
Kubernetes helps manage containerized applications, including deployment, scaling, networking, and service discovery.
AWS provides Amazon Elastic Kubernetes Service (EKS) for running Kubernetes clusters on AWS.
A simplified deployment architecture is:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Developer
|
v
Git Repository
|
v
CI/CD Pipeline
|
v
Docker Image
|
v
Amazon ECR
|
v
Amazon EKS
|
+---- Pod
|
+---- Pod
|
+---- Pod
This helped me understand how CI/CD, containers, cloud infrastructure, and Kubernetes can work together.
8. Infrastructure as Code with Terraform
Manually creating cloud resources through the AWS Console is useful for learning, but DevOps environments often require repeatable infrastructure.
This is where Terraform becomes useful.
Instead of manually creating resources, infrastructure can be described using configuration files.
A simplified Terraform example:
1
2
3
4
5
6
7
8
resource "aws_instance" "app_server" {
ami = "ami-xxxxxxxx"
instance_type = "t3.micro"
tags = {
Name = "app-server"
}
}
Terraform allows infrastructure to be managed using code and makes it easier to reproduce environments.
This introduced me to the concept of Infrastructure as Code (IaC).
9. CI/CD and AWS
Another important part of my DevOps learning is CI/CD.
A typical pipeline can look like:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Developer
|
v
GitHub / GitLab
|
v
Jenkins
|
+---- Build
|
+---- Test
|
+---- Docker Build
|
v
Amazon ECR
|
v
AWS / EKS
|
v
Application
The goal is to automate repetitive processes so that application changes can move through build, test, and deployment stages consistently.
10. Monitoring and Troubleshooting
Deploying an application is only one part of DevOps.
We also need to understand what happens after deployment.
AWS provides monitoring capabilities through services such as Amazon CloudWatch.
Monitoring can help us investigate:
- CPU utilization
- Memory-related issues when supported through agents/metrics
- Application logs
- System logs
- Error conditions
- Resource utilization
- Application behavior
I’m learning that troubleshooting is just as important as deployment.
When something doesn't work, the process is often:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Problem
|
v
Check Status
|
v
Check Logs
|
v
Check Configuration
|
v
Check Networking
|
v
Identify Root Cause
|
v
Fix
|
v
Test Again
11. What I Have Learned
My AWS learning journey has taught me that cloud and DevOps are not separate topics.
They are connected.
For example:
AWS + Linux + Git + Docker + Jenkins + Kubernetes + Terraform
can come together to create an automated application delivery environment.
The important lesson for me has been to focus on hands-on practice rather than only watching tutorials.
When I encounter an error, I try to understand:
- What failed?
- Why did it fail?
- Which component is responsible?
- How can I verify the problem?
- How can I prevent the same issue in the future?
This troubleshooting mindset is becoming one of the most valuable parts of my learning.
12. My Current Learning Roadmap
My next areas of focus are:
- Advanced AWS networking
- IAM and cloud security
- Docker optimization
- Kubernetes administration
- Amazon EKS
- Terraform
- Jenkins CI/CD
- AWS monitoring
- Infrastructure automation
- Production-style deployments
My long-term goal is to become comfortable designing and deploying cloud infrastructure rather than simply knowing individual AWS services.
Conclusion
My AWS journey started with understanding basic cloud concepts and EC2, but gradually expanded into Linux, networking, Docker, ECR, Kubernetes, EKS, Terraform, and CI/CD.
The biggest lesson I have learned so far is:
Cloud learning becomes much more meaningful when you build, break, troubleshoot, and rebuild real systems.
I’m continuing to practice AWS and DevOps through hands-on projects and labs, one problem at a time.
If you're also learning AWS or DevOps, I’d love to hear about the projects you're currently working on.
Keep learning. Keep building. Keep troubleshooting. 🚀
#AWS #AWSBuilder #AWSCloud #CloudComputing #DevOps #AmazonEC2 #Docker #Kubernetes #AmazonEKS #AmazonECR #Terraform #Jenkins #CICD #Linux #CloudEngineer #InfrastructureAsCode
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article