Every DevOps journey starts with tools.
But before learning Kubernetes, Terraform, containers, or complex CI/CD pipelines, I believe it is important to understand the fundamentals that connect everything together.
That is what I focused on during Day -1 of my AWS DevOps learning journey.
🎯 The Goal
The goal was not to master every AWS service.
It was to understand the foundation:
Linux → Git → GitHub → CI/CD → AWS
Once these pieces are clear, learning more advanced DevOps technologies becomes much easier.
Understanding DevOps
DevOps is more than just a collection of tools.
It brings together:
Development
Operations
Automation
Collaboration
Continuous delivery
Monitoring
The basic idea is to create a reliable path from writing code to running that code in production.
A simplified workflow looks like:
This workflow became the foundation for the topics I want to explore in the coming days.Linux — The DevOps Foundation
Linux is one of the most important foundations for DevOps engineers.
I focused on understanding:
File and directory structure
Permissions
Users and groups
Processes
Package management
SSH
Environment variables
Basic networking commands
Log investigation
Some commands that every DevOps engineer should become comfortable with include:
These commands become extremely useful when troubleshooting EC2 instances, containers, CI/CD runners, and Kubernetes nodes.Git and GitHub
The next foundation is version control.
Git allows us to track changes to our code and collaborate with other engineers.
A basic workflow is:
For example:
But Git becomes much more powerful when combined with CI/CD.
A simple git push can become the trigger for an entire automated delivery process.AWS Fundamentals
I also revisited some of the core AWS concepts that are important for DevOps.
AWS Region
A geographical area containing multiple Availability Zones.
Availability Zone
An isolated location within an AWS Region.
VPC
The networking boundary for AWS resources.
EC2
Virtual compute instances that can run applications, Docker, GitLab Runners, and many other workloads.
S3
Object storage commonly used for application files, backups, Terraform state, artifacts, and logs.
IAM
The authorization layer that controls what users, applications, and AWS services can access.
CloudWatch
Used for monitoring, metrics, logs, and operational visibility.
Understanding these services gives us the basic AWS vocabulary required for designing DevOps architectures.IAM — A Critical DevOps Concept
One important lesson is that DevOps is not only about automation.
Security must be part of the automation.
IAM determines:
For example, a CI/CD pipeline should not simply receive unrestricted AWS credentials.
A better approach is to use short-lived credentials and role-based access.
This becomes particularly important when we connect GitLab CI/CD with AWS.
That will be one of the areas I explore further in this journey.CI/CD Fundamentals
The next concept was understanding the basic CI/CD lifecycle.
A simplified pipeline looks like:
Instead of manually performing every step, the pipeline automates the process.
For example:
This is where DevOps starts becoming powerful.How Everything Connects
The most important takeaway from Day -1 was understanding how individual technologies fit together.
Each technology has a role.
Git manages source-code history.
GitHub/GitLab hosts and collaborates on code.
CI/CD automates delivery.
Terraform automates infrastructure.
Docker packages applications.
AWS provides the infrastructure.
EKS runs containerized workloads using Kubernetes.What I Learned
The biggest lesson from Day -1 is that learning DevOps shouldn't be about memorizing commands.
It should be about understanding how the pieces connect.
For example:
Why do we need Git?
To track and collaborate on code.
Why do we need CI/CD?
To automate software delivery.
Why do we need Terraform?
To automate infrastructure.
Why do we need Docker?
To package applications consistently.
Why do we need Kubernetes?
To orchestrate containers at scale.
Why do we need AWS?
To provide scalable cloud infrastructure and managed services.
Once we understand the "why", the tools become much easier to learn.
🚀 What's Next?
With the foundation in place, the next step is Amazon EKS.
I'll explore:
EKS architecture
Control plane
Worker nodes
Pods
Deployments
Services
Ingress
EKS networking
Container deployment
Application-to-database communication
The goal is to move from:
Understanding DevOps → Building DevOps systems
Final Takeaway
A strong DevOps foundation is not built by learning 50 tools at once.
It is built by understanding how a small number of fundamental technologies work together.
My current learning path is:
Day -1 complete.
Next stop: Amazon EKS Fundamentals. ☸️
Learn. Build. Automate. Deploy. Repeat.
Top comments (0)