RizTech Academy logo
RizTech Academy

DevOps Complete Foundation

Linux, networking, Git, containers, Kubernetes, CI/CD and infrastructure as code — the ground floor every infrastructure role is built on.

DevOps job posts list twenty tools, which makes the field look like memorisation. It is not. Underneath it is a small number of ideas — reproducibility, automation, observability — applied with whichever tool the company happens to use.

This course teaches those ideas with the tools that are genuinely standard: Linux, Git, Docker, Kubernetes, a CI/CD pipeline and infrastructure as code. Learn these and picking up the next tool takes days rather than months.

Everything is hands-on. You will break things deliberately and fix them, because that is the actual job.

Who this is for

  • Developers who want to understand how their code reaches production
  • Students targeting DevOps, SRE or platform roles
  • Anyone preparing for the AWS DevOps course

What you need first

  • Comfort with at least one programming language
  • A computer able to run Docker (8 GB RAM recommended)
  • Willingness to work in a terminal

Tools you will use

LinuxBashGit & GitHubDockerKubernetesGitHub ActionsTerraform

By the end you can

  • Work confidently on the Linux command line
  • Explain how DNS, HTTP and TLS fit together
  • Use Git properly, including branching and resolving conflicts
  • Containerise an application and write a sensible Dockerfile
  • Run containers on Kubernetes, and read and debug a broken pod
  • Build a CI/CD pipeline that tests and deploys automatically
  • Choose a deployment strategy — rolling, blue-green or canary — and roll back safely
  • Understand infrastructure as code and why manual clicking does not scale
  • Read logs and metrics to work out what is actually wrong
Reference code

Stuck? Compare your work

greetings — the tiny web service this course builds on: it threads through the hands-on modules with a multi-stage Dockerfile and Compose stack (Containers), Deployment/Service/ConfigMap/Secret manifests (Kubernetes), a GitHub Actions pipeline with a passing test suite (CI/CD), and a runnable Terraform config (Infrastructure as Code). Every artifact was built and run while writing the course.

It is there for when you are stuck, not to start from. Type the code yourself first — copying it will teach you very little.

View on GitHub
Syllabus

8 modules, 43 lessons

Work through these in order. Each lesson is short enough to finish in one sitting and ends with something to build, not a quiz.

  1. 1

    Linux Fundamentals

    The operating system nearly all servers run.

    1. Why servers run Linux15 min
    2. The filesystem and navigating it30 min
    3. Files, permissions and ownership35 min
    4. Processes, signals and services30 min
    5. grep, sed, awk and pipes35 min
    6. Shell scripting basics40 min
    7. SSH, keys and connecting to a server30 min
  2. 2

    Networking Essentials

    Enough networking to debug a production problem.

    1. IP, ports and how traffic finds a server25 min
    2. DNS, and the records you will actually edit30 min
    3. HTTP, status codes and headers30 min
    4. TLS and certificates, demystified30 min
    5. Debugging with curl, dig and traceroute30 min
  3. 3

    Git and Collaboration

    Version control as it is used on a team, not just commit and push.

    1. Git’s mental model: commits, branches, HEAD30 min
    2. Branching and merging30 min
    3. Resolving conflicts without panic25 min
    4. Pull requests and code review25 min
    5. Undoing things: reset, revert and reflog30 min
  4. 4

    Containers

    Docker, images and why "works on my machine" stopped being an excuse.

    1. What a container actually is25 min
    2. Docker: images, containers and the daemon30 min
    3. Writing a good Dockerfile40 min
    4. Multi-stage builds and keeping images small30 min
    5. Docker Compose for local development35 min
    6. Volumes, networks and persistence30 min
  5. 5

    Container Orchestration with Kubernetes

    What runs your containers in production once one machine is not enough.

    1. Why one Docker host is not enough: the case for orchestration25 min
    2. Pods, Deployments and ReplicaSets35 min
    3. Services and Ingress: how traffic reaches a pod35 min
    4. ConfigMaps, Secrets and environment configuration30 min
    5. Health checks, self-healing and scaling30 min
    6. kubectl and debugging a broken pod35 min
  6. 6

    CI/CD

    Automating the path from commit to running software.

    1. What CI/CD is for, and what it prevents20 min
    2. GitHub Actions: workflows, jobs and steps35 min
    3. A pipeline that builds and tests35 min
    4. Adding a deployment stage35 min
    5. Deployment strategies: rolling, blue-green, canary and rollback30 min
    6. Secrets in pipelines, handled safely25 min
  7. 7

    Infrastructure as Code

    Describing infrastructure in files instead of clicking in a console.

    1. Why manual infrastructure stops working25 min
    2. Terraform: providers, resources and state40 min
    3. plan, apply and reading a diff carefully30 min
    4. Modules and structuring a repository35 min
  8. 8

    Observability

    Knowing what your system is doing, before a user tells you.

    1. Logs, metrics and traces25 min
    2. Logging that is actually useful25 min
    3. Monitoring and alerting basics30 min
    4. What to do when something breaks25 min
Previous courseJava + Spring Web DevelopmentNext courseKotlin Multiplatform with Compose

Learning this with a mentor is faster

Going through a course like this one is how you qualify for our six-month internship, for selected students, mostly from Pune. Clear the interview and you build real-world projects with my mentorship.

About the internshipAll courses