AWS Builder Center

Builder Center

# My DevOps Learning Journey: From Linux to AWS, Docker, Kubernetes & CI/CD

I’m a B.Tech CSE student building my DevOps skills through hands-on practice. In this article, I share my journey from Linux and Git to AWS, Docker, Kubernetes, Jenkins, Terraform, and CI/CD, along with the lessons I’ve learned along the way.

My DevOps Learning Journey: From Linux to AWS, Docker, Kubernetes & CI/CD

Starting my DevOps journey has been one of the most interesting parts of my learning as a B.Tech CSE student.
I am still learning, still making mistakes, and still troubleshooting problems. But through hands-on practice, I have started understanding how different DevOps technologies work together.
In this article, I want to share what I have learned so far and how I am building my DevOps skills.

Why I Started Learning DevOps

As a computer science student, I wanted to understand more than just how to write an application.
I started asking questions like:
  • How does an application reach a server?
  • How are applications deployed?
  • How can deployments be automated?
  • How does cloud infrastructure work?
  • How do teams manage applications running in production?
These questions introduced me to DevOps and cloud technologies.
I started exploring Linux, Git, AWS, Docker, Kubernetes, Jenkins, Terraform, and CI/CD.

Linux — My Foundation

I started with Linux because I realized that understanding the operating system is important for working with servers and cloud environments.
I practiced:
  • File and directory management
  • Permissions
  • Processes
  • Networking
  • Package management
  • Shell commands
  • Bash scripting
  • System monitoring
Working with Linux helped me become more comfortable with the command line and understand what is happening inside a server.

Git and GitHub

Next, I focused on Git and GitHub.
I learned how to:
  • Create and clone repositories
  • Track changes
  • Create branches
  • Commit and push changes
  • Pull updates
  • Merge branches
  • Work with remote repositories
Git became an important part of my workflow because I use it to manage and document my projects.

AWS — Understanding Cloud Infrastructure

After building my Linux and Git foundation, I started learning AWS.
I began with services and concepts such as:
  • Amazon EC2
  • IAM
  • Amazon S3
  • VPC
  • Security Groups
  • Route 53
  • Load Balancing
EC2 helped me understand virtual servers in the cloud.
IAM introduced me to identity and access management.
S3 helped me understand cloud storage.
VPC helped me understand networking and how resources communicate inside AWS.
The more I practiced, the more I realized that learning AWS is not only about knowing individual services. The important part is understanding how these services work together.

Docker — Learning Containers

Docker was another important step in my DevOps journey.
Before learning Docker, I mainly thought about applications as code running directly on a machine.
Docker helped me understand how an application and its dependencies can be packaged into a container so that it can run consistently across environments.
I practiced concepts such as:
  • Images
  • Containers
  • Dockerfiles
  • Ports
  • Volumes
  • Networks
  • Docker Compose
Running containers myself and troubleshooting them made the concepts much easier to understand.

Kubernetes — Managing Containers

After Docker, I started learning Kubernetes.
Initially, Kubernetes felt complicated because there were many new concepts.
I started with:
  • Pods
  • Deployments
  • Services
  • Nodes
  • Clusters
  • Namespaces
  • ConfigMaps
  • Secrets
I also practiced Kubernetes locally to understand how applications are deployed and exposed.
One of the biggest lessons for me was that Kubernetes is not simply another container tool. It provides mechanisms for deploying, scaling, networking, and managing containerized applications.
I am still learning Kubernetes, but hands-on practice has helped me understand it much better than theory alone.

Jenkins and CI/CD

I also started learning Jenkins and CI/CD.
I wanted to understand how repetitive software delivery tasks can be automated.
A simple CI/CD flow can look like:
Code → Build → Test → Package → Deploy
Working with Jenkins helped me understand how a pipeline can automate these steps.
I am also exploring GitHub Actions to understand different approaches to CI/CD automation.

Terraform — Infrastructure as Code

Another technology I started learning is Terraform.
Terraform introduced me to Infrastructure as Code (IaC).
Instead of manually creating infrastructure through a cloud console, infrastructure can be defined using configuration files.
I am learning concepts such as:
  • Providers
  • Resources
  • Variables
  • Outputs
  • State
  • Modules
  • terraform plan
  • terraform apply
This changed the way I think about infrastructure.
Infrastructure can be treated more like code: it can be versioned, reviewed, modified, and automated.

What Hands-On Practice Has Taught Me

The biggest difference between watching tutorials and actually building things is troubleshooting.
Things don't always work on the first attempt.
I have faced problems involving configurations, permissions, networking, containers, Kubernetes resources, Jenkins, and cloud services.
Sometimes the solution is simple.
Sometimes one error leads to another problem.
But every problem has taught me to:
  1. Read the error carefully.
  2. Check the configuration.
  3. Look at logs.
  4. Test assumptions.
  5. Find the root cause.
  6. Fix the problem.
  7. Try again.
This is one of the most important things I have learned so far:
DevOps is not just about tools. It is also about problem-solving and automation.

My Current DevOps Learning Stack

Currently, I am learning and practicing:
Cloud: AWS
Operating System: Linux / Ubuntu
Version Control: Git / GitHub
Containers: Docker
Container Orchestration: Kubernetes
CI/CD: Jenkins / GitHub Actions
Infrastructure as Code: Terraform
Scripting: Bash / Python
I am not claiming to be an expert in all of these technologies. I am continuously improving through practice and projects.

What I Want to Learn Next

My DevOps journey is still at the beginning.
My next focus areas are:
  • Advanced AWS networking
  • Kubernetes
  • CI/CD automation
  • Terraform
  • Monitoring and observability
  • Cloud security
  • Infrastructure automation
  • Real-world DevOps projects
My goal is not just to learn more tools.
I want to understand how these technologies work together to build reliable and automated systems.

Final Thoughts

One thing I have realized during this journey is that DevOps cannot be learned effectively by memorizing commands or watching tutorials alone.
You need to build things.
You need to make mistakes.
You need to troubleshoot.
And you need to keep practicing.
I am currently learning, building, breaking things, fixing them, and repeating the process.
This is my first article on AWS Builder Center, and I want to use this platform to document my learning journey, projects, challenges, and lessons.
If you are also starting your DevOps journey, don't wait until you know everything.
Start small. Build something. Break it. Troubleshoot it. Learn from it. Keep going.
This is only the beginning of my DevOps journey. 🚀
# docker# devops# learning-and-development# amazon-s3# aws-cloud-development-kit
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article