DevOps 101

Practices, Tools, and Trends for Modern Engineering

Use arrow keys or on-screen buttons to navigate

What is DevOps?

It's a culture, a mindset, and a set of practices that combines software development (Dev) and IT operations (Ops) to shorten the development life cycle and deliver high-quality software continuously.

The Infinite Loop

Code

Develop & Review

Test

Automate Quality

Build

Create Artifacts

Deploy

Release to Production

Observe

Monitor & Analyze

Improve

Plan Next Iteration

Core Practices

Version Control: A single source of truth for all code and config.
CI/CD: Automating the build, test, and deployment pipeline.
Containers: Packaging applications for consistency and portability.
IaC: Managing and provisioning infrastructure through code.
Observability: Gaining deep insights into system performance.

Practice: Version Control with Git

Git is the foundation of DevOps, providing a single source of truth. It allows teams to collaborate, track history, revert changes, and manage different versions of their codebase seamlessly.

Basic Workflow:

Commit changes with a clear message.
Push to a remote server (like GitHub).
Create a Pull Request for review.

Example Commands

# Configure your identity
git config --global user.name "Your Name"

# Start tracking a project
git init
git add .
git commit -m "feat: Add initial project setup"
git push origin main

Practice: CI/CD Pipelines

Continuous Integration (CI) frequently merges code changes, running automated builds and tests.

Continuous Delivery/Deployment (CD) automates the release of validated code to staging or production. Together, they create a fast, reliable, and automated feedback loop.

GitHub Actions Example

name: Basic CI Pipeline
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - run: npm run test

Practice: Containers with Docker

Containers solve the "it works on my machine" problem by packaging an application with all its dependencies into a single, isolated unit.

Docker is the leading platform for building and running containers, ensuring consistency from development to production.

Example Dockerfile

FROM node:20-alpine
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install --production
COPY . .
EXPOSE 3000
CMD [ "node", "server.js" ]

Practice: Infrastructure as Code (IaC)

IaC manages and provisions infrastructure (networks, VMs, etc.) through code, rather than manual configuration.

Tools like Terraform and Ansible allow you to define, version, and reliably recreate your entire infrastructure on demand.

Terraform Example

provider "aws" {
  region = "us-west-2"
}
resource "aws_s3_bucket" "app_storage" {
  bucket = "my-unique-app-storage-bucket"
  tags = { Name = "MyAppStorage" }
}

Practice: Observability

Observability is about understanding a system's internal state from its external outputs, allowing you to debug novel problems.

It relies on three main pillars of telemetry data.

Metrics:

Aggregated numerical data over time.

Logs:

Timestamped records of discrete events.

Traces:

The lifecycle of a request across services.

The DevOps Toolkit

While culture is key, the right tools are essential. Here are some of the most common tools that enable DevOps practices.

GitHub

Jenkins

Docker

Kubernetes

Terraform

Ansible

Prometheus

Grafana

Azure

Vault

Emerging Trends

DevSecOps

Integrating security into the pipeline.

Platform Engineering

Building internal developer platforms.

GitOps

Git as the source of truth for operations.

FinOps

Managing cloud financial operations.

SLOs

Data-driven reliability targets.

AIOps

AI for IT operations.

Trend: DevSecOps

DevSecOps integrates security practices into the DevOps process. The goal is to "shift left"—addressing security as early as possible in the development lifecycle, not as a final gate.

Automated Security Stages

CI Stage: Static Analysis (SAST), Dependency Scanning (SCA).

CD Stage: Dynamic Analysis (DAST), Container Image Scanning.

Trend: Platform Engineering

Platform Engineering builds and operates self-service Internal Developer Platforms (IDPs). The goal is to provide developers with "paved roads"—standardized, automated toolchains that reduce cognitive load and accelerate delivery.

An IDP provides:

Automated project scaffolding & environment provisioning.
Pre-configured, reusable CI/CD pipelines.
Centralized service catalogs & monitoring dashboards.

Trend: GitOps

GitOps is a framework for Continuous Deployment that uses Git as the single source of truth for declarative infrastructure and applications.

An automated agent (like Argo CD) runs in your cluster, detects when the Git repo changes, and automatically applies those changes to the live system.

More Trends to Watch

FinOps:

Brings financial accountability to the variable spending model of the cloud.

SLOs:

A precise, numerical target for system reliability that guides engineering decisions.

AIOps:

Applying artificial intelligence to IT operations for anomaly detection and root cause analysis.

Thank You

DevOps is a journey of continuous improvement.

Questions?