---
title: "DevOps Basics"
description: "Essential terms every DevOps and cloud engineer should know."
author: "Mohammad Abu Mattar"
canonical: https://mkabumattar.com/glossary/post/devops-basics
---

# DevOps Basics

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

## Terms

### CI/CD (Continuous Integration / Continuous Delivery) (Automation)

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.

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

### Pipeline (Automation)

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.

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

### Container (Containerization)

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.

```
docker run -d -p 80:80 nginx
```

### Docker (Containerization)

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.

```
```dockerfile
FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["node", "index.js"]
```
```

### Dockerfile (Containerization)

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.

```
FROM python:3.11
COPY requirements.txt .
RUN pip install -r requirements.txt
```

### Docker Image (Containerization)

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.

```
docker pull postgres:15
```

### Container Registry (Containerization)

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.

```
docker push myrepo/myapp:latest
```

### Kubernetes (K8s) (Orchestration)

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.

```
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
```
```

### Pod (Orchestration)

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.

```
```yaml
apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx
```
```

### Deployment (Orchestration)

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.

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

### Service (Kubernetes) (Orchestration)

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.

```
```yaml
kind: Service
spec:
  selector:
    app: backend
  ports:
  - port: 80
```
```

### Namespace (Orchestration)

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.

```
kubectl create namespace production
```

### Ingress (Orchestration)

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.

```
```yaml
kind: Ingress
spec:
  rules:
  - host: app.example.com
```
```

### Helm (Orchestration)

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.

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

### Infrastructure as Code (IaC) (Infrastructure)

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.

```
```hcl
resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
}
```
```

### Terraform (Infrastructure)

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.

```
```hcl
resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}
```
```

### Ansible (Infrastructure)

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.

```
```yaml
- name: Install nginx
  apt:
    name: nginx
    state: present
```
```

### Cloud Provider (Cloud)

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.

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

### AWS (Amazon Web Services) (Cloud)

Amazon's comprehensive 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.

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

### Microservices (Architecture)

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.

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

### GitOps (Automation)

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.

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

### Version Control (Automation)

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.

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

### Artifact (Automation)

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.

```
```yaml
- uses: actions/upload-artifact@v3
  with:
    name: build-output
    path: ./dist
```
```

### Environment Variable (Configuration)

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.

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

### Secret Management (Security)

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.

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

### Load Balancer (Networking)

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

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

```
```hcl
resource "aws_lb" "main" {
  load_balancer_type = "application"
}
```
```

### Monitoring (Observability)

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.

```
kubectl top nodes
```

### Logging (Observability)

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.

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

### Alerting (Observability)

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%.

```
```yaml
alert: HighCPU
expr: container_cpu_usage_seconds_total > 0.8
for: 5m
```
```

### Blue/Green Deployment (Deployment Strategies)

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.

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

### Canary Deployment (Deployment Strategies)

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.

```
```yaml
spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
```
```

### Rollback (Deployment Strategies)

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.

```
kubectl rollout undo deployment/my-app
```

### SLA (Service Level Agreement) (Reliability)

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.

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