Week 1 · Day 2

DevOps Toolchain
Overview

Map every stage of the infinity loop to real tools. Understand the choices, install your core toolkit, and write your first shell script — your DevOps environment is ready by the end of this session.

⏱ Duration 60 min

📖 Theory 30 min

🔧 Lab 25 min

❓ Quiz 5 min

Session Overview

What we cover today

01

The 8-Stage Infinity Loop

Revisit the loop from Day 1 — now mapped to concrete tools at every stage.

02

Tool Landscape — Who Does What

Categories: SCM, CI/CD, Containers, IaC, Monitoring, Collaboration.

03

3 Real-World Toolchain Stacks

GitHub stack, GitLab stack, Azure stack — compare them side by side.

04

How to Choose Tools Wisely

Principles for avoiding tool sprawl and vendor lock-in.

05

This Course's Toolchain

The exact tools used in Days 1–35 and why they were chosen.

06

🔧 Lab — Install Your Toolkit

Git, Docker Desktop, VS Code + extensions, Node.js — all verified.

07

❓ Knowledge Check

3 questions — tools, stages, and decision principles.

Part 1 of 5

The Infinity Loop — with tools

PLAN

Jira · GitHub Issues

CODE

Git · VS Code

BUILD

npm · Maven · Docker

TEST

Jest · JUnit · Trivy

RELEASE

GH Actions · Jenkins

DEPLOY

K8s · Helm · ArgoCD

OPERATE

Terraform · Ansible

MONITOR

Prometheus · Grafana

Key Principle

Each stage has specialised tools — but the output of one stage is the input of the next. A Docker image built in BUILD is deployed in DEPLOY. Metrics from MONITOR feed back to PLAN.

💡 Rule of Thumb

You don't need to master every tool. Know one tool per stage deeply, and understand how to integrate the others. Depth over breadth.

Part 2 of 5 — Tool Landscape

Plan & Code — Where work begins

📋 PLAN — Project Management

Jira — Industry standard for sprint planning, epics, story points. Complex but powerful. Used by 70%+ of enterprise DevOps teams.
GitHub Issues + Projects — Lightweight, directly linked to code. Great for smaller teams.
Azure Boards — Part of Azure DevOps. Deep integration with Azure Pipelines and repos.
Linear — Modern, fast, developer-loved. Growing rapidly in SaaS startups.

⚠ Common Mistake

Planning tools only work if the team actually uses them. A half-used Jira board is worse than a shared spreadsheet. Start simple.

💻 CODE — Source Control

Git — The universal VCS. Every DevOps engineer must know Git deeply. Not optional.
GitHub — Largest code hosting platform. Home of most open-source. Free for public repos.
GitLab — All-in-one DevOps platform (SCM + CI + registry + security scanning). Strong enterprise.
Azure Repos — Part of Azure DevOps. Git hosting integrated with Azure Pipelines.
Bitbucket — Atlassian product. Deep Jira integration. Used in Java/enterprise shops.

Non-negotiable

Git is the single most important tool in DevOps. Every other tool in this course depends on Git — CI/CD pipelines trigger on git push, IaC is stored in Git, GitOps uses Git as source of truth.

Part 2 of 5 — continued

Build & Test — Quality gates

🔨 BUILD — Compile & Package

npm / yarn — Node.js dependency management & build scripts
Maven / Gradle — Java build tools. Gradle is faster and more flexible.
pip / poetry — Python packaging
Docker — Containerise the app into a portable image (most important build tool today)
Webpack / Vite — Frontend bundlers for JS/TS

🧪 TEST — Automated Quality

Jest — JavaScript/Node.js unit & integration testing
JUnit / TestNG — Java testing frameworks
Pytest — Python testing (elegant, minimal boilerplate)
Selenium / Playwright / Cypress — Browser E2E testing
Postman / Newman — API testing
Trivy / Snyk — Security & vulnerability scanning
SonarQube — Static code analysis, code smells, coverage gates

The 20/80 Rule

80% of bugs are caught by 20% of tests — usually unit tests. Invest heavily in fast unit tests. E2E tests are expensive and flaky. A pipeline with 200 unit tests that runs in 90 seconds beats one with 20 E2E tests that takes 40 minutes.

Part 2 of 5 — continued

Release & Deploy — CI/CD engines

🚀 RELEASE — CI/CD Pipeline Engines

GitHub Actions — Cloud-hosted, YAML, free for public repos. Zero infrastructure. Ideal for teams already on GitHub.
Jenkins — Self-hosted, open-source, 1800+ plugins, Groovy Jenkinsfile. Enterprise standard. More control, more maintenance.
GitLab CI — Built into GitLab. .gitlab-ci.yml. Strong security scanning built-in.
Azure Pipelines — Part of Azure DevOps. YAML or GUI. Free 1800 min/month.
CircleCI / TeamCity — Paid cloud CI, used in enterprises.

📦 DEPLOY — Getting Code to Servers

Kubernetes (K8s) — Container orchestration platform. De-facto standard for running containers in production at scale.
Helm — Package manager for Kubernetes. Charts are versioned K8s application packages.
ArgoCD / Flux — GitOps tools. Sync K8s cluster state to Git automatically.
Ansible — Agentless configuration management. Used to deploy to VMs when K8s isn't in the picture.
AWS CodeDeploy / Azure Deployment Slots — Cloud-native deploy services.

Part 2 of 5 — continued

Operate & Monitor — Infra & Observability

⚙️ OPERATE — Infrastructure as Code

Terraform — Provision cloud infrastructure (VMs, networks, databases) as code. Cloud-agnostic. HCL syntax.
Ansible — Configure servers after provisioning. Agentless SSH. YAML playbooks.
Pulumi — IaC using real programming languages (Python, TypeScript). Terraform alternative.
AWS CloudFormation / ARM Templates — Cloud-native IaC. Vendor-locked but deeply integrated.
Chef / Puppet — Older agent-based config management. Being replaced by Ansible in most shops.

📊 MONITOR — Observability Stack

Prometheus — Open-source metrics collection and alerting. Pull model. PromQL query language.
Grafana — Dashboards and visualisation. Works with Prometheus, Loki, and 40+ data sources.
Loki — Log aggregation by Grafana. Cheaper than Elasticsearch for log storage.
Datadog / New Relic — Full-stack SaaS observability. Easier setup, higher cost.
Jaeger / Zipkin — Distributed tracing. Track a request across microservices.
PagerDuty / OpsGenie — Alert routing, on-call scheduling.

Part 2 of 5 — continued

Beware of Tool Sprawl

Signs of Tool Sprawl

5 different teams using 5 different CI tools
Onboarding takes 2 weeks just to understand the toolchain
Nobody knows who owns certain tools or why they were chosen
Tools that haven't been updated in 2 years still running in prod
Engineers spend more time on tool maintenance than on features

⚠ The Hype Problem

A new DevOps tool trends on Hacker News every week. Not every tool deserves adoption. Evaluate based on your team's actual problems, not industry hype.

Principles for Choosing Tools

✅ Solves a real pain — not a hypothetical future problem
✅ Team can learn it in days, not months
✅ Strong community — GitHub stars, Stack Overflow, active docs
✅ Integrates with existing stack — no custom glue code
✅ Open source preferred — avoid vendor lock-in where possible
✅ Start with one per stage — expand only when you hit limits

Wisdom

"A team that uses bash scripts well beats a team that struggles with a complex tool they don't understand." Simplicity scales. Complexity kills velocity.

Part 3 of 5

Three real-world toolchain stacks

Stage	🐙 GitHub Stack	🦊 GitLab Stack	☁️ Azure Stack
Plan	GitHub Issues / Projects	GitLab Issues / Milestones	Azure Boards
Code	GitHub Repos	GitLab Repos	Azure Repos
CI/CD	GitHub Actions	GitLab CI (.gitlab-ci.yml)	Azure Pipelines
Container Reg	GHCR (GitHub Container Registry)	GitLab Container Registry	ACR (Azure Container Registry)
Deploy	GitHub Actions + kubectl	GitLab CI + Helm / ArgoCD	Azure Pipelines + AKS
IaC	Terraform (any cloud)	Terraform + GitLab Terraform state	Terraform + ARM / Bicep
Monitor	Datadog / Grafana Cloud	Prometheus + Grafana (built-in)	Azure Monitor + App Insights
Best For	Open-source teams, SaaS startups, cloud-native	All-in-one, self-hosted, security-focused enterprise	Microsoft shops, Azure-first orgs, hybrid cloud

💡 This Course

We use GitHub + GitHub Actions + Docker + Kubernetes + Terraform + Ansible + Prometheus/Grafana — a mix of the GitHub and GitLab stacks. All open-source. Works on any cloud.

Part 4 of 5

This course's toolchain — and why

🐙

Git + GitHub

Code · Plan

Universal VCS. Free repos. GitHub Actions built-in.

⚡

GitHub Actions

CI/CD

Zero setup. Cloud-hosted runners. YAML pipelines.

🏗

Jenkins

CI/CD (Enterprise)

Self-hosted, Jenkinsfile pipelines, 1800+ plugins.

🐳

Docker

Build · Package

Container images. Docker Compose for local dev.

☸️

Kubernetes

Deploy · Operate

Container orchestration. minikube for local K8s.

⛵

Helm

Deploy

Package manager for K8s. Versioned app charts.

🌿

Terraform

Operate · IaC

Cloud infra as code. Provision VMs, networks, DBs.

🤖

Ansible

Operate · Config

Agentless config management. SSH + YAML playbooks.

🔥

Prometheus

Monitor · Metrics

Pull-based metrics. PromQL. AlertManager.

📊

Grafana

Monitor · Dashboards

Dashboards for metrics + logs. 40+ data sources.

🔵

ArgoCD

GitOps · CD

Sync K8s to Git. Self-healing. Declarative.

💻

VS Code

Development

IDE with YAML, Docker, GitLens extensions.

Part 4 of 5 — continued

Tool → Course Day mapping

W2

Git + GitHub (Days 6–10)

Branching, PRs, hooks, merge strategies, cherry-pick, bisect.

W3

GitHub Actions + Jenkins (Days 11–15)

CI pipelines, testing, artifacts, CD with approval gates. Declarative Jenkinsfiles.

W4

Docker (Days 16–20)

Images, Dockerfiles, Compose, container registries, security scanning.

W5

Terraform + Ansible (Days 21–25)

IaC provisioning, modules, Ansible Roles, Vault, Jinja2 templates, IaC pipeline.

W6

Kubernetes + Helm (Days 26–28)

Architecture, Deployments, Services, Helm charts, production patterns.

W7

Prometheus + Grafana + Security (Days 29–32)

Metrics, logs, alerting, SAST, Trivy, secrets scanning.

W8

GitOps + SRE + Capstone (Days 33–35)

ArgoCD, SRE principles, postmortems, full end-to-end pipeline capstone.

📌 Today's Goal

Install tools for Weeks 2–3: Git, Docker, VS Code, Node.js. Everything else gets installed when we need it.

Part 5 of 5

🔧 Hands-On Lab

Install your DevOps toolkit — Git, Docker, VS Code, Node.js — and verify every tool is working

⏱ 25 minutes

💻 Your laptop

Mac / Windows / Linux

🔧 Lab — Step by Step

Install your toolkit

1

Install Git

Mac: brew install git | Windows: git-scm.com → download installer | Linux (Debian): sudo apt install git. After install: git --version should show 2.x.x

2

Install Docker Desktop

Go to docker.com/products/docker-desktop and download for your OS. After install, open Docker Desktop and wait until the whale icon stops animating. Then: docker --version

3

Install VS Code + Extensions

Download from code.visualstudio.com. Then install these extensions: GitLens (supercharged Git), Docker (Dockerfile syntax + container explorer), YAML (schema validation), Prettier (code formatter).

4

Install Node.js (LTS)

Go to nodejs.org and download the LTS version (20.x or 22.x). Includes npm automatically. Verify: node --version and npm --version

5

Create GitHub Account + Configure Git

Sign up at github.com if you don't have an account. Then configure Git identity (see next slide). Create your first repo: devops-35days-labs

🔧 Lab — Verification Commands

Verify everything works

bash — Run all of these

# === Verify toolkit ===
git --version
# Expected: git version 2.x.x

docker --version
# Expected: Docker version 24.x.x (or higher)

docker run hello-world
# Expected: "Hello from Docker!"

node --version
# Expected: v20.x.x or v22.x.x

npm --version
# Expected: 10.x.x

code --version
# Expected: VS Code version number

# === Configure Git identity (do once) ===
git config --global user.name "Your Full Name"
git config --global user.email "you@example.com"
git config --global core.editor "code --wait"
git config --global init.defaultBranch main

# Verify config
git config --list

bash — First repo

# === Create your course lab repo ===
mkdir devops-35days-labs
cd devops-35days-labs
git init

# Create README
echo "# DevOps 35-Day Labs" > README.md
echo "My course lab repository" >> README.md

git add README.md
git commit -m "feat: initial lab repo setup"

# Push to GitHub (create repo first at github.com)
git remote add origin \
  https://github.com/YOUR_USERNAME/devops-35days-labs.git
git branch -M main
git push -u origin main

echo "✅ Lab repo ready!"

💡 All Tools Installed?

Run each command. If any fails, resolve it before Day 3. All upcoming labs depend on Git and Docker. VS Code and Node.js are needed from Day 6 onward.

🔧 Lab — Bonus: First Docker run

Your first container

bash — Docker first steps

# Pull and run an nginx web server
docker run -d -p 8080:80 --name my-web nginx:alpine

# Check it's running
docker ps

# Open in browser: http://localhost:8080
# You should see: "Welcome to nginx!"

# See what's inside the container
docker exec -it my-web sh
ls /etc/nginx/
exit

# See the logs
docker logs my-web

# Stop and remove
docker stop my-web
docker rm my-web

# Pull a Node.js image and run it interactively
docker run -it node:20-alpine sh
node -e "console.log('Hello from a container!')"
exit

What just happened?

docker run: Downloaded the nginx image from Docker Hub and started a container
-d: Detached mode (runs in background)
-p 8080:80: Map your laptop port 8080 to container port 80
exec -it: Opened an interactive shell inside the running container

Why This Matters

In 5 commands you ran a production-grade web server without installing nginx on your machine. No configuration files. Remove the container and it's gone completely. This is the power of containerisation.

Knowledge Check

❓ Quiz Time

3 questions · 5 minutes · Instant feedback

Test your toolchain knowledge →

QUESTION 1 OF 3

In the DevOps infinity loop, which stage comes immediately after the TEST stage?

A

Deploy

B

Build

C

Release

D

Monitor

QUESTION 2 OF 3

Which tool is used in the OPERATE stage to provision cloud infrastructure like VMs and networks as code?

A

Grafana

B

Terraform

C

Jenkins

D

Docker

QUESTION 3 OF 3

What is the primary risk of adopting too many DevOps tools at once — also called "tool sprawl"?

A

Tools become more expensive

B

Security vulnerabilities increase

C

CI/CD pipelines run slower

D

Integration complexity, steep learning curves, and maintenance burden slow the team down

Day 2 — Complete

What you learned today

∞

Full Loop Mapped

Every stage — Plan to Monitor — now has real tools attached to it.

🧰

Tool Landscape

6 categories, 30+ tools. One recommended per stage to start.

📊

3 Real Stacks

GitHub, GitLab, Azure — different platforms, same lifecycle concepts.

🔧

Toolkit Installed

Git + Docker + VS Code + Node.js — ready for 33 more days of labs.

Your Day 2 Action Items

Verify all 4 tools are installed and versions confirmed
Create the devops-35days-labs GitHub repo and push first commit
Run docker run -d -p 8080:80 nginx:alpine and visit localhost:8080

Tomorrow — Day 3

Agile + DevOps

How Scrum and Kanban connect to DevOps delivery. Sprint planning with infra tasks, adding DORA metrics to retrospectives, and setting up your GitHub Project Kanban board.

No new installs needed tomorrow

Reference Slide

Full toolchain quick reference

Stage	Primary Tool	Alternatives	This Course?
Plan	Jira	GitHub Projects, Linear, Trello	GitHub Projects ✓
Code	Git + GitHub	GitLab, Bitbucket, Azure Repos	GitHub ✓
Build	npm / Docker	Maven, Gradle, Buildpacks	npm + Docker ✓
Test	Jest	JUnit, Pytest, Playwright	Jest + Trivy ✓
Release	GitHub Actions	Jenkins, GitLab CI, Azure Pipelines	GH Actions + Jenkins ✓
Deploy	Kubernetes + Helm	ECS, Nomad, Fly.io	K8s + Helm + ArgoCD ✓
Operate	Terraform	Pulumi, CDK, ARM Templates	Terraform + Ansible ✓
Monitor	Prometheus + Grafana	Datadog, New Relic, Dynatrace	Prometheus + Grafana ✓

💡 Save This Slide

This table is your toolchain cheat sheet for the entire course. Come back to it anytime you need to remember which week covers which tool.

Reference Slide

Installation cheatsheet

bash — macOS (Homebrew)

# Install Homebrew first (if not installed)
/bin/bash -c "$(curl -fsSL \
  https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install all tools at once
brew install git node
brew install --cask docker visual-studio-code

# Install VS Code extensions via CLI
code --install-extension eamodio.gitlens
code --install-extension ms-azuretools.vscode-docker
code --install-extension redhat.vscode-yaml
code --install-extension esbenp.prettier-vscode

# Verify everything
git --version && docker --version && node --version && code --version

powershell — Windows (winget)

# Install Git
winget install Git.Git

# Install Docker Desktop
winget install Docker.DockerDesktop

# Install VS Code
winget install Microsoft.VisualStudioCode

# Install Node.js LTS
winget install OpenJS.NodeJS.LTS

# After restart, open VS Code and install extensions:
# GitLens · Docker · YAML · Prettier

# Verify
git --version
docker --version
node --version

Windows Users — Enable WSL2

Enable WSL2 (Windows Subsystem for Linux) for the best DevOps experience on Windows. Run in PowerShell (Admin): wsl --install. Restart. All remaining labs use Linux bash commands.

DevOps ToolchainOverview

What we cover today

The Infinity Loop — with tools

Plan & Code — Where work begins

Build & Test — Quality gates

Release & Deploy — CI/CD engines

Operate & Monitor — Infra & Observability

Beware of Tool Sprawl

Three real-world toolchain stacks

This course's toolchain — and why

Tool → Course Day mapping

🔧 Hands-On Lab

Install your toolkit

Verify everything works

Your first container

❓ Quiz Time

What you learned today

Full toolchain quick reference

Installation cheatsheet

DevOps Toolchain
Overview