DevOps Syllabus for Beginners

This syllabus introduces DevOps concepts and tools in a progressive, hands-on

manner. DevOps is a culture and practice that unifies software development and IT
operations, enabling teams to deliver applications and services at high velocity
through automation and collaboration
aws.amazon.com
. Over the weeks, students learn Linux fundamentals, version control, CI/CD
pipelines, containerization (Docker), orchestration (Kubernetes), cloud platforms,
Infrastructure as Code (Terraform/Ansible), monitoring/logging
(Prometheus/Grafana), and security best practices. Each section includes practical
projects or exercises to reinforce learning.
Week 1: Introduction to DevOps & Linux Basics
Topics: Core DevOps principles (collaboration, automation, agile/lean culture),
DevOps lifecycle. Students discuss how Dev and Ops teams work together rather than
in silos. We introduce Linux as the foundational OS for DevOps work – covering the
shell, filesystem hierarchy, file permissions, and basic shell commands. (Linux
powers most servers and cloud instances, so proficiency with the command line is
essential.) Key Concepts: DevOps culture and benefits
aws.amazon.com
; Linux command-line, file navigation (ls, cd, cp, mv, chmod, chown); process and
job management (ps, top, kill), package management (e.g. apt or yum). Practice:
Spin up a Linux VM (or use a cloud shell) and complete exercises: create and manage
files/directories, set permissions, navigate the file system. Write a simple shell
script (e.g. backup a directory, automate a task). Read a DevOps case study or
article to illustrate the DevOps mindset in a real project.
Week 2: Linux Advanced Topics and Scripting
Topics: Deeper Linux skills: shell scripting (variables, loops, conditionals), text
processing (grep, sed, awk), user and group management, cron jobs. Networking
basics (ifconfig/ip, firewall rules, SSH). Introduction to system services
(systemctl) and logging (/var/log). Practice: Write shell scripts that parse text
files or automate deployments. Set up a simple cron job. Configure a service to
start on boot. Use SSH to connect to the Linux server and transfer files securely.
Week 3: Version Control with Git
Topics: Source control fundamentals. Git as a distributed version control system
that lets teams track code changes, work on branches, and merge updates
about.gitlab.com
. Importance of version control in DevOps – enabling continuous integration and
collaboration
about.gitlab.com
. Key Git workflows: committing, branching, merging, resolving conflicts. Using
remote repositories (GitHub/GitLab/Bitbucket) and pull/merge requests. Practice:
Initialize a Git repository for a sample project. Perform commits, explore the
history, and use branches to develop features. Push code to a GitHub (or GitLab)
repo. Simulate a team workflow: create a feature branch, merge it into main, and
resolve a merge conflict.
Week 4: Continuous Integration & Continuous Delivery (CI/CD)
Topics: CI/CD pipeline concepts. Continuous Integration (CI) means frequently
building and testing code. Continuous Delivery (CD) means automating delivery to
staging or production. Together, CI/CD pipelines automate the build-test-deploy
process
redhat.com
. Tools: Jenkins, GitHub Actions, GitLab CI/CD, or similar. We cover how to write a
simple pipeline: build an application, run unit tests, package artifacts, and (in
CD) deploy automatically. Practice: Set up a CI pipeline for a simple application
(e.g. a Python or Node.js app). Use Jenkins or a free cloud CI service to automate:
on each commit, run tests and report results. Extend the pipeline to deploy the
application to a staging environment (for example, copying files to a test server
or triggering a script). Students see how automated testing in CI can catch issues
early
redhat.com
.
Week 5: Containerization with Docker
Topics: Containers vs. virtual machines. Docker fundamentals: images, containers,
Dockerfile, Docker Hub. “Containers package an application and its runtime
environment together in a self-contained unit”
redhat.com
, ensuring consistency across environments. Students learn to create Docker images,
run containers, and manage images/containers (docker build, docker run, docker ps,
etc.). Networking basics in Docker (port mapping) and volumes (persisting data).
Practice: Install Docker. Write a Dockerfile for a simple web service (e.g. a small
Python or Node server). Build and run the image locally. Publish the image to
Docker Hub or a local registry, then pull and run it on another machine. Experiment
with environment variables and mounted volumes.
Week 6: Docker Compose and Container Networking
Topics: Docker Compose for multi-container applications. Define docker-compose.yml
to run multiple services (e.g. a web app and a database) together. Docker
networking concepts: bridge networks, linking containers, exposed ports. We also
introduce container registries (Docker Hub, ECR/GCR) and best practices
(lightweight images, multi-stage builds). Practice: Use Docker Compose to build and
run a multi-service app (for example, a web frontend and a Redis cache). Scale a
service (e.g. run multiple container replicas). Push the Compose stack definition
to Git, so it can be reused on any machine.
Week 7: Container Orchestration with Kubernetes (Basics)
Topics: Need for orchestration as container usage grows. Container orchestration
automates deployment, scaling, and management of containers
redhat.com
. Kubernetes overview: clusters, nodes, pods, deployments, and services
redhat.com
. Kubernetes control plane and worker nodes (could be local via Minikube or Docker
Desktop K8s). We cover kubectl basics and YAML configuration: deploying a pod,
creating a Deployment and a Service to expose it. Introduce Kubernetes objects:
ReplicaSet, ConfigMap, Secret, PersistentVolumeClaim. Practice: Set up a local
Kubernetes cluster (e.g. Minikube or Kind). Deploy an application container using
kubectl apply -f. Create a Service to load-balance traffic. Scale the deployment
(e.g. from 1 to 3 replicas) and observe rolling updates. Access the app through the
Kubernetes service.
Week 8: Kubernetes (Advanced Topics)
Topics: In-depth K8s concepts: Namespaces (to isolate environments), ConfigMaps and
Secrets (for configuration and credentials), volumes/storage (persistent data).
Advanced scheduling: Deployments vs StatefulSets vs DaemonSets. Introduce Helm as a
package manager for Kubernetes (optional overview). Best practices: health checks
(readiness/liveness probes), rolling updates, resource requests/limits. Practice:
Using the existing cluster, update the application with a new version and perform a
rolling update. Use a ConfigMap to inject environment variables into pods. Mount a
persistent volume (e.g. hostPath or Minikube PV) for stateful data. (Optional)
Install Helm and deploy a simple chart (e.g. NGINX).
Week 9: Cloud Fundamentals (AWS/Azure/GCP)
Topics: Introduction to cloud computing and the big three cloud providers
bmc.com
: AWS, Microsoft Azure, Google Cloud Platform (GCP). Discuss common cloud services:
compute (VM instances, serverless functions), storage (object storage like S3,
block storage), databases, networking (VPCs, load balancers), and managed
Kubernetes services (EKS, AKS, GKE). Benefits of cloud: on-demand resources,
scalability, reduced on-premises maintenance
bmc.com
. Basic cloud CLI usage and IAM concepts. Practice: Sign up for a free tier account
in AWS, Azure, or GCP. Launch a small VM (e.g. AWS EC2 or Azure VM) and SSH into
it. Create a simple cloud storage bucket (e.g. S3). (Optional) Deploy the
Dockerized app to a cloud container service (e.g. run the Docker container on AWS
ECS or Azure Container Instances). Explore the cloud console and familiarize with
the dashboard.
Week 10: Infrastructure as Code – Terraform (and CloudFormation)
Topics: Infrastructure as Code (IaC) concepts: treating infrastructure definitions
like software code
docs.aws.amazon.com
. Students learn Terraform basics: writing *.tf files to define cloud resources (VM
instances, networks, databases) in a declarative way. Terraform workflow: terraform
init, plan, apply. We discuss state files and resource lifecycle. Compare with AWS
CloudFormation/CDK as alternative IaC tools. Example resources: creating an EC2
instance or a VPC with Terraform.
“Practicing infrastructure as code means applying the same rigor of application
code development to infrastructure provisioning”
docs.aws.amazon.com
.
Practice: Install Terraform. Write Terraform configurations to provision basic
cloud resources, such as an EC2 instance and an S3 bucket on AWS (or equivalent on
Azure/GCP). Run terraform apply to create the resources, then terraform destroy.
Experiment by modifying the config (e.g. change instance type) and re-applying to
see how Terraform updates resources.
Week 11: Configuration Management – Ansible
Topics: Ansible fundamentals for server configuration management. Concepts:
Playbooks (YAML files defining tasks), inventory (list of hosts), modules (built-in
tasks). Unlike Terraform (which provisions infra), Ansible is used for configuring
software on servers (installing packages, editing config files, starting services).
We cover Ansible ad-hoc commands vs. full playbooks. Example use case: deploying
application code or configuring a web server. Practice: Set up Ansible on a control
machine. Use Ansible to configure one of the VMs (from Week 9/10) or a new VM:
write a playbook that installs NGINX, copies a configuration file, and starts the
NGINX service. Test idempotency (running the playbook twice should not change the
outcome). Experiment with variables and templates.
Week 12: Monitoring and Logging (Prometheus & Grafana)
Topics: Importance of observability in DevOps: monitoring metrics and collecting
logs. Prometheus as a metrics-based monitoring system. (Prometheus is the CNCF-
standard for metrics observability in cloud-native environments
grafana.com
.) Concepts: metric scraping, time-series database, alerting rules. Grafana for
visualization: an open-source dashboarding platform to query and display metrics
and logs
grafana.com
. Students also learn about logging: centralizing logs from applications and
containers (for example, the ELK stack or Grafana Loki for log aggregation).
“Grafana is the leading open source visualization and dashboarding platform…”
grafana.com

“Prometheus is the de facto standard for metrics-based observability in cloud-

native environments”
grafana.com
.
Practice: Deploy Prometheus and Grafana (locally or in the cloud). Instrument the
sample application to expose metrics (or run Node Exporter on a node). Configure
Prometheus to scrape these metrics. In Grafana, create a dashboard that visualizes
a key metric (e.g. request rate or CPU usage). Set up a simple alert rule in
Prometheus. For logging, you could use Grafana Loki or a simple ELK stack: ship
application logs to a central place and create a Grafana panel to display log
messages by severity.
Week 13: DevOps Security Practices (DevSecOps)
Topics: Shifting security “left” into the DevOps pipeline. Security best practices:
static code analysis (SAST), software composition analysis for dependencies,
container image vulnerability scanning, and secrets management (Vault, KMS, or
cloud secrets). Discuss network security, IAM roles/policies, and RBAC for tools
(e.g. Kubernetes RBAC). We emphasize that security should be everyone’s
responsibility; tools in the CI/CD pipeline can automatically detect
vulnerabilities.
“Automated checks and testing within a CI/CD pipeline can safeguard code and
prevent vulnerabilities”
redhat.com
.
Practice: Integrate a security scan into the CI pipeline (for example, add a step
using a linting or security tool like Trivy or SonarQube to scan the code or Docker
image). Manage a simple secret: store and retrieve it securely (e.g. use HashiCorp
Vault or AWS Secrets Manager in a script). Review and tighten permissions: ensure
the principle of least privilege is applied in IAM roles or Kubernetes
ServiceAccounts.
Week 14: Capstone Project – End-to-End DevOps Workflow
Topics: Apply all learned skills in an integrated project. Students design and
implement a simple multi-component application (e.g. a front-end service and a
back-end service or database). They use Git for version control, set up a CI/CD
pipeline that builds Docker images for the services, deploy to Kubernetes (either
on local cluster or cloud-hosted Kubernetes service), and ensure the application is
monitored and logged. Optional features: automatic scaling, storing infrastructure
config in Terraform/Ansible, and including a security scan. This project reinforces
the full DevOps lifecycle from code commit to production-like deployment.
Deliverables: A working application deployed via an automated pipeline.
Documentation of the workflow (e.g. diagrams of the pipeline and architecture).
Reflection on how DevOps practices (version control, CI/CD, containers, cloud, and
monitoring) improved the development process. Optionally, a short presentation or
demo of the working system. Sources: Authoritative DevOps and cloud resources were
used to guide this curriculum (e.g. AWS’s definition of DevOps
aws.amazon.com
, Red Hat’s explanations of CI/CD and orchestration
redhat.com

redhat.com
, Terraform’s documentation
developer.hashicorp.com
, and Grafana Labs’ descriptions of monitoring tools
grafana.com

grafana.com
). These ensure the syllabus aligns with current industry practices and tooling.