Glossary

DevOps Basics

Essential terms every DevOps and cloud engineer should know.

33 TermsPublished: 01 Apr, 2026

Devops #basics #ci-cd #kubernetes #docker #terraform

This glossary covers foundational terms used in DevOps and cloud engineering, spanning containerization, orchestration, infrastructure as code, CI/CD pipelines, observability, and deployment strategies.

Architecture

Microservices

An architectural style that structures an application as a collection of small, independently deployable services, each responsible for a specific business function.

Example

Splitting a monolithic e-commerce app into separate services for orders, payments, and inventory.

Code Snippet

1
# Each service runs in its own container and communicates via HTTP or message queues

Automation

CI/CD (Continuous Integration / Continuous Delivery)

A set of practices that automate the building, testing, and deployment of applications, enabling teams to release software faster and more reliably.

Example

A GitHub Actions workflow that runs tests on every pull request and deploys on merge to main.

Code Snippet

1
on: [push] jobs: build: runs-on: ubuntu-latest

Pipeline

An automated sequence of steps that takes source code from version control through build, test, and deployment stages.

Example

A Jenkins pipeline that builds a Docker image, runs unit tests, and pushes to a registry.

Code Snippet

1
pipeline { stages { stage("Build") { steps { sh "docker build ." } } } }

GitOps

An operational framework that applies DevOps best practices like version control, collaboration, and CI/CD to infrastructure automation, using Git as the single source of truth.

Example

Using ArgoCD to sync Kubernetes manifests stored in a Git repository to a live cluster.

Code Snippet

1
argocd app create my-app --repo https://github.com/org/repo --path k8s/

Version Control

A system that records changes to files over time so you can recall specific versions later, enabling collaboration and change tracking across a team.

Example

Using Git to track changes to application code and infrastructure configurations.

Code Snippet

1
git commit -m "feat: add Kubernetes deployment manifest"

Artifact

Any file produced during a CI/CD pipeline (such as a compiled binary, Docker image, or test report) that is stored and used in subsequent pipeline stages.

Example

A JAR file produced by a Maven build step and archived for deployment.

Code Snippet

1
```yaml
2
- uses: actions/upload-artifact@v3
3
  with:
4
    name: build-output
5
    path: ./dist
6
```

Cloud

Cloud Provider

A company that offers on-demand computing resources and services over the internet, including compute, storage, networking, and managed services.

Example

AWS, Google Cloud Platform (GCP), and Microsoft Azure are the three largest cloud providers.

Code Snippet

1
aws ec2 describe-instances --region us-east-1

AWS (Amazon Web Services)

Amazon's cloud platform offering over 200 services including compute (EC2), storage (S3), databases (RDS), and container orchestration (EKS).

Example

Hosting a static website using an S3 bucket with CloudFront as a CDN.

Code Snippet

1
aws s3 sync ./dist s3://my-bucket --delete

Configuration

Environment Variable

A dynamic named value that can affect the way running processes behave, commonly used to store configuration settings and secrets outside of source code.

Example

Storing a database connection string as an environment variable rather than hardcoding it.

Code Snippet

1
export DATABASE_URL=postgres://user:pass@localhost:5432/mydb

Containerization

Container

A lightweight, standalone, executable package that includes everything needed to run a piece of software: code, runtime, libraries, and settings.

Example

Running an Nginx web server inside a Docker container.

Code Snippet

1
docker run -d -p 80:80 nginx

Docker

An open platform for developing, shipping, and running applications inside containers, enabling consistent environments across development and production.

Example

Building a custom application image using a Dockerfile.

Code Snippet

1
```dockerfile
2
FROM node:18
3
WORKDIR /app
4
COPY . .
5
RUN npm install
6
CMD ["node", "index.js"]
7
```

Dockerfile

A text file containing a set of instructions used by Docker to automatically build a container image.

Example

A Dockerfile that sets up a Python Flask application.

Code Snippet

1
FROM python:3.11
2
COPY requirements.txt .
3
RUN pip install -r requirements.txt

Docker Image

A read-only template used to create Docker containers. Images are built from a Dockerfile and stored in a container registry.

Example

Pulling the official PostgreSQL image from Docker Hub.

Code Snippet

1
docker pull postgres:15

Container Registry

A storage and distribution system for Docker images, allowing teams to push and pull images for use in deployments.

Example

Pushing a built image to Amazon ECR or Docker Hub.

Code Snippet

1
docker push myrepo/myapp:latest

Deployment Strategies

Blue/Green Deployment

A release strategy that runs two identical production environments (blue and green) simultaneously, routing traffic to the new version only after it passes validation.

Example

Deploying v2 to the green environment while v1 is live on blue, then switching the load balancer.

Code Snippet

1
# Switch traffic by updating the load balancer target group to the green environment

Canary Deployment

A deployment technique that gradually rolls out a new version to a small subset of users before releasing it to everyone, reducing the risk of widespread failures.

Example

Routing 5% of traffic to a new service version and monitoring error rates before a full rollout.

Code Snippet

1
```yaml
2
spec:
3
  strategy:
4
    type: RollingUpdate
5
    rollingUpdate:
6
      maxSurge: 1
7
      maxUnavailable: 0
8
```

Rollback

The process of reverting an application or infrastructure to a previous stable state after a failed or problematic deployment.

Example

Reverting a Kubernetes deployment to the previous revision after a production error.

Code Snippet

1
kubectl rollout undo deployment/my-app

Infrastructure

Infrastructure as Code (IaC)

The practice of managing and provisioning infrastructure through machine-readable configuration files rather than manual processes or interactive tools.

Example

Defining an AWS VPC and subnets in a Terraform configuration file.

Code Snippet

1
```hcl
2
resource "aws_vpc" "main" {
3
  cidr_block = "10.0.0.0/16"
4
}
5
```

Terraform

An open-source IaC tool by HashiCorp that lets you define cloud and on-prem resources in human-readable configuration files that can be versioned and shared.

Example

Provisioning an EC2 instance on AWS using a Terraform resource block.

Code Snippet

1
```hcl
2
resource "aws_instance" "web" {
3
  ami           = "ami-0c55b159cbfafe1f0"
4
  instance_type = "t2.micro"
5
}
6
```

Ansible

An open-source automation tool used for configuration management, application deployment, and task automation using human-readable YAML playbooks.

Example

Installing and starting Nginx on a remote server using an Ansible playbook.

Code Snippet

1
```yaml
2
- name: Install nginx
3
  apt:
4
    name: nginx
5
    state: present
6
```

Networking

Load Balancer

A device or service that distributes incoming network traffic across multiple backend servers, improving availability, scalability, and reliability.

Example

An AWS ALB distributing HTTPS traffic across three EC2 instances running the same application.

Code Snippet

1
```hcl
2
resource "aws_lb" "main" {
3
  load_balancer_type = "application"
4
}
5
```

Observability

Monitoring

The practice of continuously collecting, tracking, and analyzing metrics from systems and applications to detect issues and understand performance.

Example

Using Prometheus to scrape CPU and memory metrics from Kubernetes nodes.

Code Snippet

1
kubectl top nodes

Logging

The process of recording events, errors, and informational messages generated by applications and infrastructure to support debugging and auditing.

Example

Aggregating logs from all containers in a cluster into a central Elasticsearch index.

Code Snippet

1
kubectl logs -f deployment/my-app --all-containers=true

Alerting

A mechanism that automatically notifies engineers when monitored metrics exceed defined thresholds or when critical events occur in a system.

Example

A Grafana alert that sends a Slack notification when pod CPU usage exceeds 80%.

Code Snippet

1
```yaml
2
alert: HighCPU
3
expr: container_cpu_usage_seconds_total > 0.8
4
for: 5m
5
```

Orchestration

Kubernetes (K8s)

An open-source container orchestration platform that automates deploying, scaling, and managing containerized applications across a cluster of machines.

Example

Deploying a web application across three replicas using a Kubernetes Deployment.

Code Snippet

1
```yaml
2
apiVersion: apps/v1
3
kind: Deployment
4
metadata:
5
  name: my-app
6
spec:
7
  replicas: 3
8
```

Pod

The smallest deployable unit in Kubernetes, consisting of one or more containers that share the same network namespace and storage.

Example

A pod running a single Nginx container.

Code Snippet

1
```yaml
2
apiVersion: v1
3
kind: Pod
4
metadata:
5
  name: nginx
6
spec:
7
  containers:
8
  - name: nginx
9
    image: nginx
10
```

Deployment

A Kubernetes resource that declaratively manages a set of identical pods, handling rollouts and rollbacks automatically.

Example

Updating an application to a new image version using a rolling update strategy.

Code Snippet

1
kubectl set image deployment/my-app my-app=myrepo/myapp:v2

Service (Kubernetes)

A Kubernetes abstraction that defines a logical set of pods and a policy to access them, providing stable networking and load balancing.

Example

Exposing a backend deployment on port 80 via a ClusterIP Service.

Code Snippet

1
```yaml
2
kind: Service
3
spec:
4
  selector:
5
    app: backend
6
  ports:
7
  - port: 80
8
```

Namespace

A Kubernetes mechanism that partitions cluster resources between multiple users or teams, providing scope for names and resource isolation.

Example

Creating separate namespaces for staging and production environments.

Code Snippet

1
kubectl create namespace production

Ingress

A Kubernetes API object that manages external HTTP/HTTPS access to services within a cluster, typically providing routing rules and TLS termination.

Example

Routing traffic to different services based on URL path using an Nginx Ingress controller.

Code Snippet

1
```yaml
2
kind: Ingress
3
spec:
4
  rules:
5
  - host: app.example.com
6
```

Helm

A package manager for Kubernetes that allows you to define, install, and upgrade complex Kubernetes applications using reusable charts.

Example

Installing a Prometheus monitoring stack with a single Helm command.

Code Snippet

1
helm install prometheus prometheus-community/kube-prometheus-stack

Reliability

SLA (Service Level Agreement)

A formal commitment between a service provider and a customer that defines the expected level of service, including uptime guarantees and response times.

Example

An AWS SLA guaranteeing 99.99% uptime for EC2 instances in a given region.

Code Snippet

1
# SLA is a business contract, not a code construct

Security

Secret Management

The practice of securely storing, accessing, and auditing sensitive information such as API keys, passwords, and certificates used by applications and pipelines.

Example

Storing database credentials in AWS Secrets Manager and injecting them into pods at runtime.

Code Snippet

1
aws secretsmanager get-secret-value --secret-id prod/db/password

Was this useful?

Continue on this topic

The same subject, covered a different way from the glossary above.

You might also enjoy

Check out some of our other posts on similar topics

4 related posts