← Back to Cloud and Infrastructure

Cloud and Infrastructure Glossary

Key terms from the Cloud and Infrastructure course, linked to the lesson that introduces each one.

1,060 terms.

A

Accelerated computing instances
Accelerated computing instances are VMs equipped with Graphics Processing Units (GPUs), Field-Programmable Gate Arrays (FPGAs), or custom silicon chips designed for specific computational tasks.
Lesson 70 — Accelerated Computing Instance Types
Access Analyzer
Access Analyzer is an automated tool that continuously scans your IAM policies and resource-based policies to detect potential security risks.
Lesson 372 — Access Analyzer for Policy Review
Access Key ID
A public identifier (like a username)
Lesson 343 — Access Keys and Credential Management
Access Reviews
Scheduled workflows prompt managers to certify that team members still need their current access. Unreviewed or denied access is automatically revoked, preventing privilege creep.
Lesson 2857 — Identity Governance and Lifecycle
Accidental damage
A user with delete permissions might accidentally wipe critical resources
Lesson 334 — The Principle of Least Privilege
actions
Actions are the actual tasks performed at that workstation—the specific operations that transform or move your code.
Lesson 1838 — CodePipeline Architecture and ComponentsLesson 1841 — Pipeline Actions and Action Types
activities
In Azure Data Factory, activities are the building blocks that perform actual work.
Lesson 2650 — ADF Pipeline Activities and Control Flow
Activity Log
The Activity Log is a platform log that records subscription-level events: resource creation, deletion, policy changes, and access attempts.
Lesson 2359 — Azure Monitor and Activity Logs
Adding users
Adding users means placing them into a group so they inherit that group's permissions.
Lesson 351 — Assigning Users to Groups
Admin Account
Admin Account is a simple username/password pair built into each registry, useful for quick testing but not recommended for production due to limited control and auditability.
Lesson 1092 — ACR Authentication and RBAC
Admission Controller
Applies resource changes when pods are created or restarted
Lesson 1455 — Vertical Pod Autoscaler (VPA) Basics
Agents
Think of it like a construction site: the Jenkins Master (controller) is the project manager who assigns tasks, while Agents (workers) are the crews who actually build things.
Lesson 1771 — Jenkins Architecture: Master and Agents
aggregate
An aggregate is a cluster of domain objects treated as a single unit for data changes.
Lesson 2559 — Domain-Driven Design Basics
aggregated ClusterRole
An aggregated ClusterRole is a special ClusterRole that doesn't define its own rules directly.
Lesson 1386 — Aggregated ClusterRoles
Akamai
Akamai is the oldest and largest CDN provider with the most extensive Points of Presence (PoPs) globally—over 4,000 locations.
Lesson 594 — Popular CDN Providers Overview
ALARM
The threshold has been breached
Lesson 670 — CloudWatch Alarms and Actions
AlarmARN
The specific CloudWatch alarm that can trigger rollback
Lesson 890 — Stack Rollback Configuration
Alert
defines what events trigger notifications and which Flux resources to watch (like specific Kustomizations or HelmReleases). This is your filter: "Tell me when this deployment changes status."
Lesson 1928 — Flux Notifications and Alerts
alias
An alias is a friendly pointer or label that references a specific function version.
Lesson 486 — Function Versions and Aliases
Allocation
Allocation is attributing costs to the right owners—teams, projects, or departments.
Lesson 2137 — Cost Management Fundamentals
Alternating-User Rotation
Two sets of credentials alternate. While one is active, the other is rotated. Zero downtime, but requires managing two users.
Lesson 2240 — AWS Secrets Manager Rotation
Amortization
Amortization means spreading that upfront payment evenly across the commitment period.
Lesson 2148 — Amortizing Reserved Instance Costs
Analogy
Think of data scanning like taxi fares—you pay per mile traveled. Partitioning is like organizing your city into zones so you only drive through relevant neighborhoods. Caching is like remembering the route. Efficient formats are like taking highways instead of side streets.
Lesson 237 — Classic/Legacy Load BalancersLesson 440 — Google Cloud Firestore and DatastoreLesson 1132 — Kubeconfig Files and ContextsLesson 1346 — Node Affinity vs Node SelectorLesson 1384 — ServiceAccount RBAC IntegrationLesson 1919 — Introduction to Flux and GitOps PhilosophyLesson 2670 — Cost Management for Query Engines
Annual full tests
Annual full tests are the minimum industry baseline, but many organizations test more frequently based on their RTO and RPO requirements.
Lesson 2415 — DR Testing and Validation Frequency
Apache Airflow
Apache Airflow is the most popular open-source choice, defining workflows in Python.
Lesson 2626 — Workflow Orchestration Tools
Apache Flink
Apache Flink is a dedicated distributed processing engine with true event-time processing and sophisticated state management.
Lesson 2611 — Stream Processing Frameworks
API backends with variable traffic
Handle webhook endpoints or REST APIs where traffic is unpredictable
Lesson 470 — FaaS Use Cases and Anti-Patterns
API contract
An API contract is a formal agreement between a consumer and provider about request/response formats, endpoints, status codes, and behavior.
Lesson 2585 — Contract Testing and API Contracts
API gateway
An API gateway is more like a sophisticated concierge desk—it not only directs traffic but also authenticates guests, translates requests, enforces rules, and aggregates responses.
Lesson 521 — API Gateway vs Load Balancer
API key
An API key is a unique string that identifies who's calling your API.
Lesson 540 — API Keys and Usage Plans
API Keys
API Keys are simple shared secrets assigned to clients.
Lesson 2539 — Serverless API Authentication
API Server ↔ etcd
The API server uses client certificates to authenticate with etcd, protecting your cluster's entire state database
Lesson 1115 — Component Communication and Security
API server availability
The Kubernetes API is always reachable
Lesson 1505 — Managed Kubernetes Overview
App Engine
App Engine is Google's fully managed platform-as-a-service (PaaS) that lets you deploy applications without managing the underlying infrastructure.
Lesson 105 — GCP App Engine Standard and Flexible
AppArmor
Both SELinux (Security-Enhanced Linux) and AppArmor are Linux kernel security modules that enforce mandatory access control.
Lesson 1396 — SELinux and AppArmor Profiles
Application
In CodeDeploy, an Application is simply a logical name that groups everything related to a specific deployment.
Lesson 1832 — CodeDeploy Application and Deployment Groups
application code
In cache-aside, your application code is responsible for cache management:
Lesson 2595 — Cache-Aside and Read-Through Patterns
application controller
The application controller is the heart of GitOps reconciliation.
Lesson 1878 — ArgoCD Architecture Overview
Application Health Extension
A lightweight agent installed on each VM that reports whether the application inside is responding correctly. Think of it like a nurse checking each patient's vital signs in a hospital ward.
Lesson 324 — VMSS Health Monitoring and Automatic Repairs
Application Layer
A named container that represents your software project. You might have applications named "WebApp," "APIService," or "MobileBackend."
Lesson 1832 — CodeDeploy Application and Deployment Groups
Application logs
Application logs are generated by your software—the code you or your team wrote.
Lesson 655 — Application Logs vs System Logs
Application-consistent
Required for databases, enterprise applications, and any stateful workload where data integrity is critical
Lesson 2421 — Application-Consistent vs. Crash-Consistent Backups
Application-controlled
The app explicitly tells the load balancer where to route
Lesson 2467 — Sticky Sessions and Affinity
Application-level failover handling
Application-level failover handling means building intelligence into your code to detect, recover from, and adapt to these disruptions without crashing or losing data.
Lesson 2487 — Application-Level Failover Handling
Application-level logging
Application-level logging refers to how your application code generates logs.
Lesson 1433 — Logging Architecture in Kubernetes
AppRole
AppRole is Vault's machine-oriented authentication method designed for automated systems like containers, VMs, or serverless functions.
Lesson 2258 — AppRole Authentication for Applications
appVersion
The version of the application your chart deploys (e.g., nginx:1.21.0). This is informational—it tells users which software version they're installing, separate from the chart packaging version.
Lesson 1535 — Chart.yaml Metadata
Argo Rollouts
Argo Rollouts is a Kubernetes controller that works alongside ArgoCD to provide these advanced deployment capabilities beyond what standard Kubernetes Deployments offer.
Lesson 1912 — Progressive Delivery with Argo Rollouts
ArgoCD
ArgoCD is the most popular GitOps operator for Kubernetes.
Lesson 1863 — GitOps Tooling Landscape
argocd-server
The API/UI server should run 2+ replicas behind a load balancer
Lesson 1917 — ArgoCD High Availability Setup
Asynchronous invocation
In serverless computing, asynchronous invocation means sending an event to a function and immediately getting control back, while the function processes your request in the background.
Lesson 487 — Function Invocation TypesLesson 498 — Async and Fire-and-Forget PatternLesson 506 — AWS Lambda: Event Sources and Triggers
asynchronous pattern
This asynchronous pattern is for long-running tasks.
Lesson 2522 — Step Functions Integration Patterns
At-Least-Once
The message definitely arrives, but might arrive multiple times. The system retries until it gets an acknowledgment, risking duplicates if the consumer crashes after processing but before acknowledging. This is the most common pattern because it balances reliability with implementation simplicity. Your consumer must handle duplicate messages gracefully (idempotency).
Lesson 2712 — Message Delivery Guarantees
At-Most-Once
The message arrives zero or one time, never duplicated. If delivery fails, tough luck—it's gone. This is the fastest approach because there's no retry logic or tracking. Think of it like shouting across a noisy room: you say it once and move on, regardless of whether anyone heard.
Lesson 2712 — Message Delivery Guarantees
Attack vectors
Attack vectors are the paths adversaries use to exploit vulnerabilities—stolen credentials, misconfigured network rules, or compromised supply chains.
Lesson 2860 — Threat Detection Fundamentals
Attribute Collection
Gathering stack traces, request bodies, or environment metadata is expensive. Every span.setAttribute() call has a cost.
Lesson 2071 — Instrumentation Overhead
Attributes
Attributes are the fields within an item (like spreadsheet cells).
Lesson 430 — DynamoDB: Fundamentals and Data Model
Audit gaps emerge
Mixed encrypted/unencrypted resources are hard to track
Lesson 2839 — Encryption by Default
Audit logs
Continuously monitor which requests are denied and verify they're actually malicious
Lesson 1629 — Security Policies Best Practices
Authentication
Authentication is proving your identity—confirming who you are.
Lesson 332 — Authentication vs Authorization
Authentication & Authorization
Verifies who you are and what you're allowed to do
Lesson 1116 — Kubernetes API Server Overview
Authorization
Your boarding pass determines which gate you can access, whether you can use the lounge, and which seat is yours. Your identity is already proven—now the system checks your permissions.
Lesson 332 — Authentication vs Authorization
Auto Scaling Group
The Auto Scaling Group (ASG) is the manager that holds everything together.
Lesson 289 — Auto Scaling Components
Auto sync
Auto sync is like authorizing "leave at door"—the moment it arrives, it's deployed.
Lesson 1884 — Sync Policies and Manual vs Auto Sync
Autohealing
Autohealing is the automatic recovery mechanism.
Lesson 329 — MIG Health Checks and Autohealing
Automated Enforcement
Configure guardrails using cloud-native policy engines to block non-compliant deployments. For example, deny EC2 instance creation if Project tag is missing.
Lesson 2964 — Cost Allocation Tags
Automatic Deletion
Old snapshots are automatically removed when they exceed retention limits, preventing storage costs from spiraling out of control.
Lesson 132 — Snapshot Lifecycle Management
Automatic Load Balancing
The queue handles distribution without custom logic
Lesson 2720 — Competing Consumers Pattern
Automatic optimization
The cloud scales resources without human intervention
Lesson 32 — Elasticity and Cost Benefits of Auto-Scaling
Automatic recovery
If a server fails, users simply get routed to another—no data is lost because nothing was stored locally
Lesson 42 — Stateless Application Design
Automatic rotation
Automatic rotation is handled by the KMS (Key Management System).
Lesson 2287 — Key Rotation FundamentalsLesson 2304 — Encryption Key Rotation Strategies
Automatically created
The service creates the role when you first use that service
Lesson 357 — Service-Linked Roles
Autopilot mode
Autopilot mode is Google's managed experience where GKE handles the entire infrastructure layer for you.
Lesson 1476 — GKE Cluster Types: Standard vs Autopilot
Availability zone outage
The entire data center zone loses connectivity
Lesson 416 — Multi-AZ Failover Process
Available
Sufficient replicas are running and ready
Lesson 1169 — Deployment Rollout Status
AWS DataSync
AWS DataSync is an online agent-based service that automates and accelerates data transfer over the network.
Lesson 2810 — Large-Scale Data Transfer Services
AWS DocumentDB
AWS DocumentDB is a fully managed document database service that emulates MongoDB's API.
Lesson 442 — DocumentDB and MongoDB-Compatible Services
AWS Management Console
AWS Management Console is the graphical, point-and-click interface.
Lesson 1462 — EKS Cluster Creation Options
Azure Data Box
AWS Snowball/Snowmobile and Azure Data Box are ruggedized physical devices shipped to your data center.
Lesson 2810 — Large-Scale Data Transfer Services
Azure Synapse Analytics
Azure Synapse Analytics is Microsoft's answer to the lakehouse architecture.
Lesson 2635 — Azure Synapse Analytics

B

backend
A backend is simply the storage location Terraform uses for your state file.
Lesson 784 — State Backend Types Overview
Background deletion
Parent is deleted immediately; children are cleaned up asynchronously
Lesson 1125 — Owner References and Garbage Collection
Backups
Backups are complete, independent copies of data that are usually transferred to separate storage locations.
Lesson 2417 — Backup vs. Snapshot: Understanding the Difference
Backward compatibility
Backward compatibility means new schema versions can read old data.
Lesson 2638 — Schema Evolution and VersioningLesson 2732 — Event Schema Evolution
Bandwidth
Bandwidth is the maximum capacity of your network pipe, measured in bits per second (Gbps, Mbps).
Lesson 72 — Network Performance Across Instance TypesLesson 2226 — Bandwidth vs Throughput vs Latency
base image
A base image is the first layer—the foundation—of a container image.
Lesson 978 — Base Images and Parent Layers
Baseline establishment
Baseline establishment is the foundation.
Lesson 2969 — Cost Anomaly Detection
Baseline learning
The system learns your typical daily, weekly, and seasonal spending
Lesson 2987 — Cost Anomaly Detection Systems
Basic Authentication
Basic Authentication is the simplest approach: you provide a username and password to access the registry.
Lesson 1079 — Private Registry Authentication
batch processor
The batch processor is your best friend for performance.
Lesson 2087 — Best Practices and Performance Considerations
Benchmark Regularly
Measure P50, P95, and P99 latency with and without instrumentation. A healthy overhead target is under 5% latency increase.
Lesson 2071 — Instrumentation Overhead
Better performance
Smaller objects are faster to process and distribute
Lesson 1212 — EndpointSlices
Better scalability
The storage system doesn't need complex locking mechanisms
Lesson 145 — Object Immutability Concepts
Bicep CLI
The Bicep CLI is your main command-line tool for compiling and validating Bicep files.
Lesson 922 — Bicep Tooling and CLI
Bicep extension for Visual Studio Code
The Bicep extension for Visual Studio Code is essential for productive development.
Lesson 922 — Bicep Tooling and CLI
bindings
Think of it like a smart mailbox: the trigger is the sensor that detects new mail arrival (starting your function), and bindings are the automated sorting system that places incoming mail on your desk and takes outgoing mail to the post office—all without you walking to the mailbox yourself.
Lesson 511 — Azure Functions: Bindings and Triggers
Blacklisting
Blacklisting is the opposite—you specify which countries cannot access your content, while everyone else is allowed.
Lesson 592 — Geographic Restrictions and Content Blocking
blameless postmortem
A blameless postmortem is a structured review process that examines what happened, why it happened, and how to prevent recurrence—all without blaming individuals.
Lesson 2134 — Post-Incident Reviews and Blameless Postmortems
Blast radius
Blast radius is the scope of potential damage from a chaos experiment—how many systems, users, or transactions could be affected if something goes wrong.
Lesson 2305 — Data Key Caching PatternLesson 2493 — Blast Radius and Safety Controls
Blast Radius Limitation
If an attacker breaches one segment (say, a web server), they're trapped in that zone. They cannot easily pivot to your database servers in a different segment. The damage is contained.
Lesson 2390 — Network Segmentation Fundamentals
Blob triggers
Execute when files are added/modified
Lesson 511 — Azure Functions: Bindings and Triggers
Block storage
Block storage is like a set of numbered lockers—you get raw, fixed-size chunks of space that you can organize however you want.
Lesson 125 — Block Storage vs Other Storage TypesLesson 140 — Object Storage vs. Block vs. File
blocks
Block storage divides data into fixed-size chunks called blocks, each with a unique identifier.
Lesson 113 — Block Storage Overview
Blue environment
Blue environment is live, serving all production traffic through your load balancer's target group
Lesson 277 — Blue-Green Deployments with Load Balancers
Breach impact grows
Unencrypted data stolen in a breach is immediately readable
Lesson 2839 — Encryption by Default
broker
A broker is a Kafka server that stores data and serves client requests.
Lesson 2608 — Introduction to Apache Kafka
bucket
The name of your S3 bucket (must already exist)
Lesson 785 — Configuring S3 Backend
bucket policy
A bucket policy is a JSON document you attach to a storage bucket to define permissions.
Lesson 164 — Bucket Policies and Access Control
Buckets
Buckets are containers that hold objects.
Lesson 141 — Objects, Buckets, and Keys
build steps
Think of a Jenkins job like cooking a meal: build steps are the actual cooking instructions (chop, sauté, bake), while post-build actions are what you do after cooking (garnish, plate, clean up).
Lesson 1776 — Build Steps and Post-Build Actions
built-in controllers
While you learned previously that admission controllers intercept API requests before objects are persisted, built-in controllers are the ready-to-use implementations that handle common operational needs.
Lesson 1407 — Built-in Admission Controllers
Burst capacity
A temporary allowance for sudden spikes (like filling a bucket that drains at the steady-state rate)
Lesson 531 — Throttling and Rate Limiting
Business Rule Validation
Apply domain logic—checking that prices are positive, dates fall within reasonable ranges, or required fields aren't null. These rules prevent logically invalid but technically parsable data from polluting your pipeline.
Lesson 2624 — Data Quality in Batch Pipelines
By Workload Type
Place latency-sensitive applications close to users on one provider, batch processing jobs on the cheapest provider, and GPU-intensive workloads where GPU availability and pricing are best.
Lesson 2761 — Multicloud Architecture Patterns: Workload Distribution

C

CA bundle
The certificate authority used to verify your webhook's TLS certificate
Lesson 1411 — Webhook Configuration and Registration
CA unavailability
If the control plane is down, proxies can't renew certificates
Lesson 1628 — Certificate Rotation and Expiry
CaaS
CaaS is like a pod hotel—you get standardized, efficient rooms (containers) that are ready to use, but you still control what goes inside them
Lesson 18 — Container as a Service (CaaS) Introduction
CaaS sits in between
The cloud provider manages the container orchestration platform (the system that runs and coordinates your containers), while you maintain control over your containers' contents and configurations. You don't manage the underlying servers or container runtime, but you have more control than PaaS over how your applications are packaged and deployed.
Lesson 18 — Container as a Service (CaaS) Introduction
Cache
Cache is about speeding up repeated work.
Lesson 1738 — Cache vs Artifacts: Performance Optimization
cache hit rate
A cache hit rate is the percentage of requests served directly from CDN edge caches versus those requiring origin server retrieval (cache misses).
Lesson 2680 — CDN Cache Analytics and Hit Rates
Cache Hit Ratio
Cache Hit Ratio is your most important metric—it shows what percentage of requests were served from the edge cache versus fetching from your origin.
Lesson 608 — Performance Monitoring and Analytics
Cache Miss
The edge server does not have the content in its cache, so it must fetch it from the origin server first, then deliver it to the user (and typically store it for future requests).
Lesson 585 — Cache Hit vs Cache Miss
cache mount
A cache mount is a persistent directory that survives across builds.
Lesson 1027 — Cache Mounts for Dependencies
Cache-Control headers
Cache-Control headers are HTTP instructions you send in your response that tell CDNs and browsers exactly how to cache content.
Lesson 596 — TTL and Cache Control Headers
Cache-Control HTTP header
The Cache-Control HTTP header is how your origin server communicates TTL and caching rules:
Lesson 587 — TTL and Cache Control Headers
Cadence
Temporal and Cadence are open-source alternatives that let you define workflows in general-purpose code (Go, Java, Python, TypeScript) that can run anywhere—on-premises, multi-cloud, or hybrid environments.
Lesson 2529 — Temporal and Alternative Orchestrators
Canary Deployment Pattern
The Canary Deployment Pattern is a release strategy where you deploy new code to a small subset of users or servers before rolling it out to everyone.
Lesson 1665 — Canary Deployment Pattern
Capacity
The resources.requests.storage field defines how much storage you need (e.g., 5Gi).
Lesson 1297 — Creating PersistentVolumeClaims
Cardinality
Cardinality is the count of unique combinations across all label values.
Lesson 630 — Metric Cardinality and Dimensionality
cascading deletion
This is called cascading deletion—the parent takes its children with it.
Lesson 1905 — Application Deletion and Finalizers
Cassandra
Cassandra is a distributed NoSQL database that excels at write-heavy workloads.
Lesson 2096 — Backend Storage Considerations
Centralized logging
Centralized logging means all logs from all sources flow into a single, searchable repository.
Lesson 657 — Centralized Logging Concepts
Centralized routing
The transit gateway manages all inter-VPC traffic
Lesson 218 — Transit Gateway Concepts
Centralized service registry
A single source of truth (like Consul or a custom registry) that tracks services regardless of their cloud location. Services register themselves with metadata including cloud provider, region, and network endpoints.
Lesson 2784 — Multicloud Service Discovery
Certificate automation
The mesh handles certificate generation, rotation, and distribution
Lesson 1618 — Mutual TLS (mTLS) Fundamentals
Certificate managers
verifying certificates are issued and valid
Lesson 1914 — Resource Health Customization
Certificate problems
Certificate problems are frequent culprits.
Lesson 1630 — mTLS Troubleshooting and Verification
change set
A change set is like a "preview" or "diff" of what will happen when you update your stack.
Lesson 851 — Stack Updates and Change SetsLesson 878 — Stack Updates and Change Sets
chargeback
Both showback and chargeback are cost allocation strategies that assign cloud expenses to specific teams or business units, but they differ fundamentally in accountability:
Lesson 2146 — Showback vs Chargeback ModelsLesson 2966 — Showback vs Chargeback Models
Chart
Instead of manually applying individual YAML files, Helm bundles related Kubernetes resources into a single package called a Chart.
Lesson 1520 — What is Helm and Why Use It?
Checkov
Checkov is a policy-as-code tool that scans Terraform, CloudFormation, Kubernetes manifests, and more.
Lesson 2884 — Security Scanning in IaC Tests
Child modules
Child modules are separate, self-contained configurations that the root module calls to create reusable infrastructure patterns.
Lesson 800 — Root Module vs Child Modules
Child Process Inheritance
Environment variables are inherited by all child processes, spreading secrets throughout your process tree.
Lesson 2270 — Environment Variables for Secrets
Choosing poorly
Choosing poorly means "hot partitions"—imagine if 80% of customers had the same ID!
Lesson 438 — Cosmos DB Partitioning and Request Units
circuit breaker
A circuit breaker is a design pattern that monitors calls to downstream services and "trips" (opens) when failures exceed a threshold.
Lesson 501 — Circuit Breaker Pattern
client
The client is responsible for determining the network location of available service instances.
Lesson 2575 — Service Discovery Patterns
Cloud Interconnect
After learning about AWS Direct Connect and Azure ExpressRoute, Google Cloud offers its own suite of private connectivity solutions called Cloud Interconnect.
Lesson 2205 — Google Cloud Interconnect Options
Cloud Storage Events
Your function fires when objects are created, deleted, or updated in a bucket. Common for image processing, file validation, or backup workflows.
Lesson 515 — Google Cloud Functions: Event-Driven Architecture
Cloud VPN Gateway
This is the cloud provider's end of the tunnel—a managed service that terminates your VPN connection in the cloud. You configure it with routing preferences (static or dynamic via BGP), IP addresses, and which VPC or virtual network it connects to.
Lesson 2199 — VPN Gateway Configuration
Cloud-config
A YAML-based declarative format that's more powerful:
Lesson 87 — User Data and Cloud-Init
cloud-controller-manager
The cloud-controller-manager is a control plane component that embeds cloud-specific logic, allowing Kubernetes to interact directly with your cloud provider's APIs (AWS, Azure, GCP, etc.).
Lesson 1101 — Control Plane Components IntroductionLesson 1107 — Cloud Controller Manager
CloudFormation stack
A CloudFormation stack is what happens when AWS reads your template and provisions those resources in your account.
Lesson 846 — CloudFormation Templates and Stacks
CloudFormation template
A CloudFormation template is a text file that declares what infrastructure you want—EC2 instances, S3 buckets, VPCs, databases, and their configurations.
Lesson 846 — CloudFormation Templates and Stacks
Cluster Autoscaler
The Cluster Autoscaler (CA) is a component that automatically adjusts the size of your Kubernetes cluster by adding or removing nodes based on resource demand.
Lesson 1510 — Cluster Autoscaler Configuration
cluster generator
The cluster generator is an ApplicationSet generator that discovers all registered clusters in ArgoCD and creates one Application per cluster automatically.
Lesson 1909 — Cluster Generator for Multi-Environment
cluster-admin
The superuser role with unrestricted access to all resources across the entire cluster. Use this sparingly and only for actual cluster administrators. Binding this to a ServiceAccount or user grants complete control.
Lesson 1385 — Default ClusterRoles
ClusterIP
ClusterIP is the default Service type in Kubernetes.
Lesson 1204 — ClusterIP Service Type
CodeBuild
CodeBuild is a fully managed continuous integration service that compiles your source code, runs unit tests, and produces deployment-ready artifacts.
Lesson 1812 — CodeBuild: Managed Build Service Overview
CodeDeploy
CodeDeploy is free for EC2 and on-premises deployments.
Lesson 1820 — Pricing Model for AWS Code Services
cold start
This initialization process—called a cold start—includes:
Lesson 463 — Cold Starts and Warm StartsLesson 481 — Cold Starts and Warm Starts
Cold Storage
Cold Storage (Archive tier) is for rarely accessed data—annually or less:
Lesson 118 — Hot, Warm, and Cold Storage Tiers
Collector
The Collector is a standalone service that receives telemetry from applications, processes it (filtering, batching, enriching), and forwards it to backends.
Lesson 2074 — OpenTelemetry Architecture and Components
Color Coding
Color Coding is the most common approach:
Lesson 2106 — Threshold Indicators and Alerts
Colorblind-Friendly Palettes
The most common form is red-green colorblindness. Never use red and green as your only differentiators. Instead, pair colors with patterns, icons, or labels. Tools like Grafana offer colorblind-safe preset palettes (e.g., blue-orange schemes).
Lesson 2105 — Color Theory and Accessibility
Columnar Storage
Data is stored in a highly compressed columnar format optimized for analytical workloads, enabling fast scans of specific columns across billions of rows.
Lesson 2636 — Google BigQuery Fundamentals
Command history
the exact RUN, COPY, and ADD instructions from the build
Lesson 986 — Inspecting Image Layers
command model
Think of it like a restaurant: the command model is the kitchen where orders are processed and fulfilled (writes happen here).
Lesson 574 — CQRS Pattern with Events
community cloud
A community cloud is a deployment model where cloud infrastructure is shared by several organizations that have common concerns—such as security requirements, compliance needs, or mission objectives.
Lesson 24 — Community Cloud Model
Compaction
Compaction is a special retention mode that keeps only the latest value for each message key.
Lesson 2610 — Kafka Retention and Storage
compensating transaction
A compensating transaction is a pre-defined operation that reverses or mitigates the business impact of a previously completed action.
Lesson 2587 — Compensating TransactionsLesson 2735 — Compensating Transactions
Complete audit trail
Every change is preserved with full context
Lesson 2508 — Event Sourcing with FunctionsLesson 2596 — Event Sourcing Fundamentals
Complete History
Every state change is preserved forever. You know not just what the data is, but how it got there.
Lesson 2726 — Event Sourcing Fundamentals
Compliance as Code
Compliance as Code is about detection and validation.
Lesson 2336 — Policy as Code vs. Compliance as Code
Compliance Inheritance Model
The Compliance Inheritance Model describes how certain compliance controls are automatically inherited from your cloud provider, while others remain squarely on your shoulders.
Lesson 2330 — Compliance Inheritance Model
Compliance perspective
Most frameworks require management event logging (who changed what configuration). Data event logging is needed for sensitive data access patterns (HIPAA, PCI DSS).
Lesson 2352 — Management vs Data Event Logging
Compliance Requirements Translation
Compliance Requirements Translation is the systematic process of converting these regulatory obligations into machine-readable policy definitions that tools like AWS Config, Azure Policy, or Open Policy Agent can enforce.
Lesson 2337 — Compliance Requirements Translation
Compression matters
GitLab compresses artifacts automatically, but smaller is always faster. Exclude unnecessary files from both caches and artifacts using .gitignore-style patterns.
Lesson 1765 — Cache Optimization and Artifacts
Compute
Compute is the processing power — the "brain" of cloud operations.
Lesson 8 — Cloud Infrastructure Components
Computed attributes
Computed attributes are values that Terraform or the cloud provider determines after creating a resource.
Lesson 819 — Local Values and Computed Attributes
concurrency
In serverless architectures, concurrency refers to the number of function instances executing simultaneously.
Lesson 473 — Concurrency and Scaling in FaaSLesson 509 — AWS Lambda: Concurrency and Scaling ControlsLesson 2550 — Concurrency Management
Concurrency limits
Concurrency limits are caps you can set to control how many of these instances are allowed to run at once.
Lesson 478 — Function Concurrency Limits
condition
A boolean expression that must evaluate to true
Lesson 759 — Variable Validation Rules
Conditions
Control whether certain resources are created based on logic. For instance, only create a database replica if the environment is "production."
Lesson 847 — Template Structure and Sections
ConfigMap
A ConfigMap is a Kubernetes resource that stores non-confidential configuration data as key-value pairs.
Lesson 1247 — ConfigMap Fundamentals and Use Cases
Configuration blob
A reference to the JSON file containing runtime settings (environment variables, exposed ports, default command)
Lesson 980 — Image Manifest and Metadata
Configuration externalization
Configuration externalization is critical.
Lesson 2828 — Connection String and Configuration Updates
Configuration File
The grafana.ini file (or environment variables) controls server settings like HTTP port, database backend, and security options.
Lesson 1993 — Installing and Configuring Grafana
Configurations
Configurations are YAML or Python files that declared what you wanted to build—the complete specification of your infrastructure.
Lesson 936 — Deployment Manager Architecture and Components
Connection draining
Connection draining is a load balancer feature that gives your target a "grace period" to finish handling existing requests before fully removing it from service.
Lesson 279 — Connection Draining and Graceful Shutdown
connection pool
A connection pool is like a parking lot for database connections.
Lesson 450 — Connection Pooling and Management
Consistent low latency
Consistent low latency is critical (cold starts matter)
Lesson 2530 — Serverless Database Concepts
Consistent Processes
Authentication, patching, backup schedules, incident response—these should work the same way whether a server is physical, virtual on-prem, or in the cloud.
Lesson 2815 — Hybrid Operations and Coexistence
constant throttling
However, constant throttling means your CPU limits are too low for your workload's actual needs—time to raise them or optimize your code.
Lesson 1340 — CPU Throttling Behavior
Constraint
An instance of a template that applies specific parameters. This is where you say "enforce this rule on these resources."
Lesson 1413 — OPA Gatekeeper Architecture
Constraints
While Constraint Templates define the shape and logic of a policy rule, Constraints are the instances that actually enforce those rules.
Lesson 1415 — Implementing Constraints
consumer group
A consumer group is a set of consumers working together to process a topic.
Lesson 2608 — Introduction to Apache Kafka
Consumer groups
multiple consumers share topic partitions for parallel processing. Each partition is consumed by exactly one consumer in a group
Lesson 2609 — Kafka Producers and Consumers
Consumers
Think of it like a newspaper: the producer is the journalist who writes a breaking news story (the event), and consumers are all the readers who receive and react to that news—some might share it on social media, others might change their travel plans, and some might simply file it away.
Lesson 568 — Event Producers and Consumers
container
A container is a lightweight, standalone, executable package that bundles everything an application needs to run: the code itself, runtime environment, system tools, libraries, and settings.
Lesson 960 — What Are Containers?Lesson 974 — Image vs Container: Key Differences
container image
A container image is a pre-packaged, ready-to-run bundle that contains everything your application needs: the code, runtime environment, libraries, dependencies, and configuration files—all wrapped up in a single, immutable file.
Lesson 965 — Container Portability BenefitsLesson 973 — What is a Container Image?
container registry
A container registry is a centralized repository for storing, managing, and distributing container images.
Lesson 1060 — What is a Container Registry
context
A context is simply a convenient label that bundles together which cluster you want to access, which user credentials to use, and optionally which namespace to default to.
Lesson 1055 — Build Configuration and ContextLesson 1132 — Kubeconfig Files and Contexts
Context objects
Context objects are special data structures that hold information about the workflow run, repository, environment variables, and secrets.
Lesson 1692 — Context and Expression Syntax
Contextual access
Contextual access means authorization decisions adapt to risk signals in real-time:
Lesson 2848 — Continuous Verification and Contextual Access
Continuous Authentication
Sessions are periodically re-validated using factors like device health, location, and behavioral biometrics. If a user's risk score changes mid-session (e.g., sudden geo-location jump), access can be challenged or revoked.
Lesson 2402 — Continuous Verification and Monitoring
Continuous Delivery
Continuous Delivery means your code is always in a deployable state and automatically deployed to a staging or pre-production environment.
Lesson 1645 — What is Continuous Delivery and Deployment?
Continuous Learning
Foster an environment where discussing cloud costs is as normal as discussing performance metrics. Regular cost reviews, lunch-and-learns about optimization techniques, and celebrating cost-saving wins all reinforce this mindset.
Lesson 2952 — Building a FinOps Culture
Continuous Reconciliation
In GitOps, continuous reconciliation is the automated process where a controller constantly compares what's running in your infrastructure against what's defined in your Git repository.
Lesson 1852 — What is GitOps?Lesson 1858 — Continuous Reconciliation
Control Plane
While most service mesh observability focuses on application traffic flowing through the data plane, the control plane is the brain that orchestrates everything.
Lesson 1100 — Kubernetes Cluster Architecture OverviewLesson 1567 — Data Plane vs Control PlaneLesson 1641 — Control Plane Observability
Cookie-based affinity
The load balancer inserts a cookie identifying the backend instance
Lesson 2467 — Sticky Sessions and Affinity
Cookie-based stickiness
The load balancer inserts a special cookie (AWSALB for ALBs) in the response, then reads it on subsequent requests to route to the same target.
Lesson 278 — Session Affinity and Sticky Sessions
cooldown period
A cooldown period is a configurable waiting time (typically 300 seconds/5 minutes by default) that prevents Auto Scaling from initiating another scaling action immediately after a previous one completes.
Lesson 293 — Cooldown PeriodsLesson 303 — Cooldown Periods and Warmup
CoreDNS
CoreDNS is Kubernetes' built-in DNS server that runs as a pod (usually in the kube-system namespace).
Lesson 1113 — CoreDNS for Service Discovery
Correlation
Correlation means embedding trace context—specifically trace IDs and span IDs—into your logs and metrics, creating a golden thread that connects all three pillars of observability.
Lesson 657 — Centralized Logging ConceptsLesson 2069 — Correlation with Logs and Metrics
correlation ID
A correlation ID is a unique identifier (like a tracking number) attached to a request when it enters your system.
Lesson 661 — Correlation IDs and Request Tracing
Cost
fixing issues in code is cheaper than post-deployment remediation
Lesson 2875 — Introduction to Infrastructure Testing
Cost allocation
Track spending by project, team, or customer. Your cloud bill can break down storage costs by tag, showing exactly how much Project:Alpha is costing versus Project:Beta.
Lesson 169 — Object Tagging and Metadata
Cost Centers and Business Units
Cost Centers and Business Units are organizational labels you attach to cloud resources so you can track which team spent what.
Lesson 2145 — Cost Centers and Business Units
Cost of abstraction exceeds risk
Building and maintaining portable layers is expensive
Lesson 2777 — Lock-In vs Portability Trade-offs
Cost tracking
Identify which department or application is generating cloud bills (e.g., CostCenter: Marketing)
Lesson 63 — VM Tags and Resource Organization
counter
A counter is a metric that only increases over time (or resets to zero).
Lesson 627 — Metric Types: Counters and GaugesLesson 1949 — Metric Types: Counter
CPU Utilization
CPU Utilization is the most popular metric.
Lesson 304 — Scaling Metrics Selection
Credential Management at Scale
Credential Management at Scale is about structuring credential access through folders, domains, and external secret managers.
Lesson 1804 — Credential Management at Scale
CRI-O
CRI-O is specifically designed for Kubernetes.
Lesson 962 — Container Runtime Basics
Cross-account roles
Cross-account roles are IAM roles that allow identities in one cloud account to temporarily assume permissions in another account.
Lesson 354 — Cross-Account Roles
CSI driver
A CSI driver is a vendor-provided piece of software that implements the CSI specification.
Lesson 2771 — Storage Abstraction with CSI
Current build progress
Real-time indicator when builds are active
Lesson 1782 — Jenkins UI Navigation and Monitoring Builds
Custom
Only when predefined roles are too broad or too narrow
Lesson 392 — GCP IAM Roles: Basic, Predefined, Custom
Custom Resource Types
You can build your own resource types (called "private extensions") for internal tools or workflows that CloudFormation doesn't natively support.
Lesson 892 — CloudFormation Registry and Extensions
Custom Script Extension
The Custom Script Extension is particularly powerful.
Lesson 100 — Azure VM Extensions and Custom Script
Customer Gateway
This represents your on-premises VPN device or router. You register it with the cloud provider by providing its public IP address and routing type. Think of it as telling the cloud: "This is where my office network lives."
Lesson 2199 — VPN Gateway Configuration
cutover window
A cutover window is your scheduled downtime or low-traffic period for making the switch.
Lesson 2813 — Cutover Planning and Rollback Strategies

D

Dashboard
A dashboard is your canvas—a collection of panels that display metrics, logs, or other data in charts, graphs, and tables.
Lesson 1112 — Add-on Components and ExtensionsLesson 1995 — Creating Your First Dashboard
Dashboard as Code
Dashboard as Code means defining your entire dashboard configuration in structured files (typically JSON or YAML) that live in version control alongside your application code.
Lesson 2111 — Dashboard as Code and Version Control
Data
The prefix indicating you're referencing a data source (not a managed resource)
Lesson 115 — Object Storage OverviewLesson 751 — Referencing Data Source Attributes
Data Catalog
A centralized metadata repository that automatically discovers and catalogs your data assets across S3, RDS, Redshift, and other sources. It maintains schema information and makes data searchable.
Lesson 2643 — AWS Glue Overview
Data coming IN
Data coming IN (ingress) is typically free across all major cloud providers.
Lesson 199 — Internet Connectivity Costs
Data Consistency Checks
After failover completes, validate that data integrity is maintained—no corruption, no orphaned records, no application state mismatches. Compare checksums, run application-level health checks, and verify read/write operations function correctly.
Lesson 2488 — Failover Testing and Validation
Data going OUT
Data going OUT (egress) is where costs accumulate.
Lesson 199 — Internet Connectivity Costs
Data Integrity Validation
Data Integrity Validation is the systematic verification that your backed-up data hasn't been corrupted, is complete, and can be successfully restored.
Lesson 2907 — Data Integrity Validation
data lake
A data lake is a storage architecture that holds vast amounts of raw data in its native format until it's needed.
Lesson 2627 — Data Lake Concepts and Architecture
Data Plane
The workers that handle the actual traffic. These are the sidecar proxies (which you learned about in the previous lesson) deployed alongside each service instance. Every request flowing between your services passes through data plane proxies. They perform the heavy lifting: routing requests, enforcing mTLS, load balancing, retries, timeouts, and collecting telemetry—all in real-time.
Lesson 1567 — Data Plane vs Control PlaneLesson 1578 — Istio Data Plane and Envoy Proxies
Data replication
Data replication is the foundation—your databases and storage must continuously copy data across regions.
Lesson 2453 — Geographic Distribution and Multi-Region Design
Database
A namespace grouping related tables (e.g., sales_data, marketing_analytics)
Lesson 2658 — Athena Data Catalogs and Databases
database engine
The database engine is the software that actually runs your database—the "brain" that understands SQL and manages your data.
Lesson 397 — RDS Architecture and Components
Database Load
A simple metric showing how many active sessions are running. If this exceeds your instance's capacity (e.g., your instance has 2 vCPUs but load is at 5), you have contention.
Lesson 412 — Performance Insights
Database per Service Pattern
The Database per Service Pattern means each microservice owns and manages its own private data store.
Lesson 2561 — Database per Service Pattern
Databases
Databases are specialized storage systems designed to organize and retrieve structured information quickly.
Lesson 8 — Cloud Infrastructure Components
Datastore
Datastore is the older service, designed for server-side applications with a focus on scalability and strong consistency.
Lesson 440 — Google Cloud Firestore and Datastore
DB instance
A DB instance is the actual database server running in the cloud.
Lesson 397 — RDS Architecture and Components
dead-letter queue
A dead-letter queue (DLQ) is a separate queue or storage location where failed events are sent for later investigation or reprocessing.
Lesson 488 — Function Error Handling and RetriesLesson 553 — Dead Letter QueuesLesson 2714 — Dead Letter Queues
Deadline propagation
Deadline propagation means each service in a call chain inherits and respects the remaining time budget from its caller.
Lesson 2591 — Timeout and Deadline Propagation
Declarative Application Setup
Declarative Application Setup means defining your ArgoCD Applications as Kubernetes resources (YAML manifests) stored in Git, just like any other Kubernetes object.
Lesson 1888 — Declarative Application Setup
Declarative Configuration
Your entire system's desired state is described declaratively in Git (YAML, JSON, HCL, etc.). You specify what you want, not how to achieve it.
Lesson 1852 — What is GitOps?
declarative integration pattern
This declarative integration pattern means less plumbing code and faster development focused on business logic rather than infrastructure connections.
Lesson 511 — Azure Functions: Bindings and Triggers
Declarative management
Everything is defined in Git as YAML manifests
Lesson 1919 — Introduction to Flux and GitOps Philosophy
Decoupling
The publisher doesn't need to know who's consuming the message
Lesson 559 — SQS-SNS Fan-Out Pattern
Dedicated Connection
A physical Ethernet port dedicated exclusively to you (1 Gbps, 10 Gbps, or 100 Gbps)
Lesson 2212 — AWS Direct Connect Fundamentals
default backend
A default backend is a fallback Service that catches all unmatched requests.
Lesson 1229 — Default Backend Configuration
default deny policy
A default deny policy is a NetworkPolicy that blocks all incoming (ingress) or outgoing (egress) traffic to selected pods unless explicitly allowed by other policies.
Lesson 1243 — Default Deny Policies
Defense in depth
Even if security group rules are misconfigured, Network ACLs provide a second layer
Lesson 1246 — NetworkPolicy Best PracticesLesson 2379 — DDoS Protection LayersLesson 2396 — Network ACLs for Subnet Isolation
Degraded
Some resources are failing (CrashLoopBackOff, failed readiness probes)
Lesson 1885 — Application Health and Sync Status
delta processing
Process only new or modified records since the last run—this is called delta processing or incremental loads.
Lesson 2625 — Batch Processing Optimization
Dependencies
The state file tracks relationships between resources. If your database must exist before your application server, or if a security group depends on a VPC, these dependencies are recorded. This ensures resources are created, updated, or destroyed in the correct order.
Lesson 701 — State File Contents and Structure
Dependency mapping
Dependency mapping means documenting every connection: which apps call which APIs, which databases serve which applications, which services authenticate against which identity providers.
Lesson 2829 — Dependency Mapping and Migration Order
Dependency-aware triggering
Dependency-aware triggering means downstream service pipelines automatically kick off when upstream dependencies change.
Lesson 1669 — Microservices Pipeline Orchestration
Deploy Stage
After your code is built (via a Build Stage), the Deploy Stage is where your application actually goes live.
Lesson 1843 — Deploy Stages and Deployment Actions
Deployment Flexibility
Containers let teams deploy microservices independently, on different schedules, without coordinating massive release windows. Update your inventory service Tuesday, your checkout service Thursday—each in its own container, with zero impact on the others. The immutable infrastructure pattern (from the previous lesson) ensures each deployment is clean and predictable.
Lesson 969 — Microservices and Container Affinity
Deployment Group Layer
Within each application, you define one or more deployment groups representing different environments or configurations. For example, your "WebApp" application might have deployment groups called "WebApp-Production" and "WebApp-Staging."
Lesson 1832 — CodeDeploy Application and Deployment Groups
deregistration delay
Connection draining (also called deregistration delay) solves this problem by allowing in-flight requests to complete gracefully before the target is fully removed.
Lesson 241 — Connection Draining and Deregistration
description
A human-readable explanation of the variable's purpose. While optional, it's invaluable documentation for anyone using your configuration, including your future self.
Lesson 755 — Variable Declaration Syntax
Desired Capacity
Your starting point and target. This is how many instances you want running right now under normal conditions. Auto Scaling will work to maintain this number unless metrics trigger scaling actions.
Lesson 292 — Minimum, Maximum, and Desired CapacityLesson 310 — Capacity Limits and Constraints
Destination
The IP address range (in CIDR notation) the traffic is trying to reach
Lesson 180 — Route Tables Basics
developer portal
A developer portal is a unified web interface that brings together everything a developer needs to build, deploy, and operate applications in one place.
Lesson 2924 — Introduction to Developer Portals
digest
A digest is a cryptographic hash (typically SHA-256) of the manifest itself.
Lesson 995 — Image Manifest and Digest
dimensions
Dimensions are name-value pairs that identify unique metric streams within a namespace.
Lesson 630 — Metric Cardinality and DimensionalityLesson 669 — CloudWatch Metrics and Namespaces
Direct Connect Gateway
A Direct Connect Gateway is a globally available resource that acts as a central hub for your Direct Connect connection.
Lesson 2214 — Direct Connect Gateway
Disadvantages
First access is always slow (cache miss), potential cache stampede on popular items, stale data if not invalidated properly.
Lesson 2697 — Cache-Aside (Lazy Loading) Pattern
Discover
Discover is your interactive log explorer.
Lesson 2029 — Kibana Index Patterns and Discover
Distance
AZs are typically separated by miles (but close enough for synchronous replication)
Lesson 2454 — Availability Zones and Data Center Distribution
distributed cache
A distributed cache is a high-speed, in-memory data store replicated across multiple nodes.
Lesson 2469 — Distributed Caching for Stateful Data
Docker Engine
Docker Engine is the most familiar runtime.
Lesson 962 — Container Runtime Basics
Docker volumes
Docker volumes are storage mechanisms that exist outside the container's filesystem but can be mounted into containers.
Lesson 1035 — Introduction to Docker Volumes
document
A document is a single JSON object representing one log entry.
Lesson 2018 — Elasticsearch Fundamentals for Logging
Documentation
The code itself documents your infrastructure. New team members can read the files to understand exactly what resources exist and how they're configured.
Lesson 47 — Infrastructure as Code Philosophy
Documented
The code itself is the documentation
Lesson 684 — What is Infrastructure as Code?
Domain name
The domain suffix for hostnames (e.g., mycompany.internal)
Lesson 227 — DHCP Options Sets
DR
While backup focuses on creating copies of your data, DR is about the entire process of getting your business operations running again after a disaster—whether that's a data center fire, cyberattack, natural disaster, or major infrastructure failure.
Lesson 2405 — What is Disaster Recovery (DR)?
Drawbacks
If Server A fails or gets removed, your session is lost. Also, sticky sessions can create uneven load distribution if some users stay logged in much longer than others.
Lesson 242 — Session Affinity (Sticky Sessions)
drift
Drift means your real infrastructure no longer matches your IaC definition.
Lesson 702 — State ReconciliationLesson 705 — State Refresh and Drift Detection
Durability
Storing messages temporarily or permanently
Lesson 2602 — Streaming Architecture Patterns
Durable Functions
Durable Functions is an extension of Azure Functions that adds state management and orchestration capabilities.
Lesson 512 — Azure Functions: Durable Functions
Dynamic
PVs are automatically created on-demand when users request storage
Lesson 1289 — PersistentVolume (PV) Fundamentals
dynamic ports
A container orchestrator like Amazon ECS or Kubernetes might launch the same application on port 32768 today and port 32771 tomorrow—these are called dynamic ports.
Lesson 258 — ALB and Container Integration

E

Edge caching
Edge caching means storing copies of that content at CDN Points of Presence (PoPs) around the world, so users get responses from nearby locations instead of traveling all the way to the origin every time.
Lesson 584 — Origin Servers and Edge Caching
Edge Location
The servers within a PoP that actually cache and serve content
Lesson 583 — CDN Architecture and Points of Presence
Edge Locations
Edge Locations are mini data centers distributed globally that:
Lesson 10 — Edge Locations and Points of PresenceLesson 611 — Edge vs. Origin: The Request Flow
Efficient storage
Common layers (like an OS base) are stored once
Lesson 976 — Union Filesystem Mechanics
egress
A list of rules allowing outgoing connections. Each rule can specify destinations (where pods can send traffic).
Lesson 1235 — NetworkPolicy Specification Structure
egress charges
Network data transfer costs—often called egress charges—are fees cloud providers impose when data leaves their network.
Lesson 2159 — Network Data Transfer Costs
Egress-Only Internet Gateway
An Egress-Only Internet Gateway is a special gateway designed specifically for IPv6 traffic.
Lesson 198 — Egress-Only Internet Gateway
eksctl
eksctl is the dedicated EKS cluster management tool.
Lesson 1462 — EKS Cluster Creation Options
ElastiCache for Memcached
A simpler, multithreaded engine optimized for straightforward key-value caching with horizontal scaling across multiple nodes.
Lesson 2690 — AWS ElastiCache Overview
Eliminates Persistent Threats
Attackers who compromise a system and install backdoors lose access when that instance is replaced. Regular instance rotation becomes a security control, not just an operational practice.
Lesson 2838 — Immutable Infrastructure for Security
emptyDir
Creates an empty directory when the Pod starts. Perfect for temporary scratch space or sharing data between containers. Data is lost when the Pod is deleted.
Lesson 1151 — Pod Storage and Volumes Basics
Encrypt traffic
All service-to-service communication is encrypted by default
Lesson 1618 — Mutual TLS (mTLS) Fundamentals
Encryption at rest
While addressable (not mandatory), encryption is considered industry standard
Lesson 408 — Encryption at RestLesson 792 — State Encryption at RestLesson 2327 — HIPAA for Healthcare Data
Encryption overhead
Manually configuring TLS for every connection is error-prone
Lesson 1617 — Service Mesh Security Overview
Endpoint
A virtual network interface that connects a sandbox to a network. Think of it as a network cable plugged into your container.
Lesson 1041 — Docker Network Architecture
Endpoint Services
Endpoint Services are the receiving end: they expose a service (like an API, database, or application) so others can connect via Private Link.
Lesson 2397 — Private Link and Endpoint Services
Endpoints
Endpoints are the automatically-generated objects that maintain this mapping.
Lesson 1211 — Endpoints Objects
Enrichment
Enrichment means adding extra information that wasn't in the original log—like the server's hostname, geographic region, environment name, or even looking up a user's email from their ID.
Lesson 660 — Log Parsing and Enrichment
Enterprise Discount Program
An Enterprise Discount Program is a contractual agreement between your organization and a cloud provider that offers reduced rates in exchange for a spending commitment over a defined period (typically 1-3 years).
Lesson 2166 — Discount Negotiation and EDP
ENTRYPOINT alone
The container runs that executable, period.
Lesson 1009 — ENTRYPOINT: Container Executable
Environment Variables
Environment Variables are set in your Lambda configuration and appear as system environment variables in your function's runtime.
Lesson 508 — AWS Lambda: Environment Variables and Secrets
Ephemeral infrastructure
Ephemeral infrastructure means containers and VMs come and go.
Lesson 2004 — Why Centralized Logging
ephemeral test environment
An ephemeral test environment is a short-lived, isolated copy of your infrastructure created solely for testing IaC changes.
Lesson 2883 — Ephemeral Test Environments
error budget
An error budget is the inverse of your SLO—it's the maximum amount of unreliability you're allowed before breaking your service level promise.
Lesson 2118 — The Concept of Error Budgets
ETag
An ETag (Entity Tag) is a unique identifier—typically a hash or version string—that represents a specific version of a resource.
Lesson 2674 — ETag and Conditional Requests
etcd
The cluster's memory. This distributed key-value store holds all cluster data — what pods should exist, their configurations, secrets, and current state.
Lesson 1101 — Control Plane Components Introduction
etcd backups and high availability
Your cluster state is safe
Lesson 1505 — Managed Kubernetes Overview
evaluation logic
Understanding the evaluation logic is crucial because even one misconfigured policy can accidentally lock out legitimate users or expose sensitive resources.
Lesson 364 — Policy Evaluation Logic
evaluation period
An evaluation period is a time window (e.g., 5 minutes).
Lesson 642 — Alarm Evaluation Periods and Datapoints
event
An event is any action or occurrence that signals your function to execute.
Lesson 462 — Event-Driven Execution Model
Event replay
Event replay means re-reading these stored events and running them through your processing logic again.
Lesson 2731 — Event Replay and Reprocessing
Event Time
Event Time is the timestamp when the event actually happened in the real world (when the user clicked, when the sensor read the temperature, when the transaction occurred).
Lesson 2604 — Event Time vs Processing Time
Event-driven
Each data record represents something that happened—a purchase, temperature reading, or API call—connecting naturally to event-driven architectures you've already studied.
Lesson 2600 — What is Streaming Data?
Event-Driven Invocation Pattern
The Event-Driven Invocation Pattern is a serverless architecture approach where functions execute automatically when specific events occur, rather than being continuously running or manually triggered.
Lesson 2501 — Event-Driven Invocation Pattern
Event-driven processing
Trigger automation when budgets exceed thresholds or anomalies are detected (tying back to your budget management and alerts from lesson 2972).
Lesson 2973 — Cost Allocation APIs and Automation
Events
A chronological log of every action CloudFormation takes (creating resources, encountering errors, rolling back). This is your primary troubleshooting tool
Lesson 857 — CloudFormation Console and Stack Management
eventual consistency
Scenarios where eventual consistency is acceptable
Lesson 533 — API Gateway Caching
Exact
Matches only if the URL path is exactly the specified path
Lesson 1223 — Basic Ingress Rules and Paths
Exactly-Once
The holy grail—each message processed precisely once, no more, no less. This requires distributed transactions, deduplication tracking, and often significant performance overhead. True exactly-once is extremely difficult across distributed systems; many "exactly-once" implementations actually mean "effectively-once" through idempotent processing or transactional coordination.
Lesson 2712 — Message Delivery Guarantees
Example flow
A crawler discovers new data → triggers a cleaning job → if successful, triggers an aggregation job → finally triggers a data quality validation job. Each step depends on the previous one's success.
Lesson 2648 — Glue Job Triggers and Workflows
Example scenario
A database writing thousands of small customer records benefits from storage offering 10,000+ IOPS.
Lesson 112 — Storage Performance Metrics: IOPS, Throughput, and Latency
Example use case
A table partitioned by UserId with sort key OrderDate could have an LSI with sort key OrderStatus to quickly find all orders for a user by status.
Lesson 433 — DynamoDB Secondary Indexes: GSI and LSI
Execution environment
Edge functions are more constrained (limited CPU time, memory, and available APIs) to maintain fast startup
Lesson 612 — Introduction to Edge Functions
executor
An executor is a slot for running a single job on an agent.
Lesson 1779 — Jenkins Build Agents and Executors
Exponential backoff
Exponential backoff means each retry waits exponentially longer:
Lesson 2590 — Retry Pattern with Exponential Backoff
Exporters
Exporters are pluggable modules that send telemetry to specific backends—Jaeger, Zipkin, Prometheus, cloud vendors, etc.
Lesson 2074 — OpenTelemetry Architecture and Components
ExpressRoute circuit
An ExpressRoute circuit is the fundamental resource that represents your dedicated connection.
Lesson 2203 — Azure ExpressRoute Fundamentals
External names
Public domain names are forwarded to public DNS servers on the internet (if your subnet has internet connectivity via an Internet Gateway or NAT Gateway)
Lesson 223 — DNS Resolution in VPCs
External service failures
A downstream API is temporarily unavailable
Lesson 553 — Dead Letter Queues
ExternalName Service
An ExternalName Service is a special type of Kubernetes Service that doesn't route traffic to Pods like ClusterIP, NodePort, or LoadBalancer Services do.
Lesson 1209 — ExternalName Services
ExternalSecret
Now that you've set up your SecretStore or ClusterSecretStore (which connects Kubernetes to your external secret manager), the ExternalSecret is the resource that actually requests specific secrets and brings them into your cluster.
Lesson 1280 — ExternalSecret Resource

F

Failback
Failback is the process of migrating workloads, data, and traffic back to your primary region once it's been repaired and validated.
Lesson 2443 — Failback Procedures
Failure Detection
Implement health checks that detect stuck jobs, out-of-memory errors, or data source unavailability. Alert teams immediately when thresholds are breached (e.g., job running 2x longer than baseline).
Lesson 2623 — Batch Job Monitoring and Logging
Failure isolation
A database issue in one service won't cascade to others
Lesson 2561 — Database per Service Pattern
Faster execution
More CPU power means your code runs faster, reducing execution time
Lesson 2545 — Function Memory and CPU Optimization
FastPath
FastPath is a feature that bypasses the ExpressRoute gateway for the data plane while keeping the control plane intact.
Lesson 2217 — ExpressRoute Gateway and FastPath
fault domain
A fault domain is a physical or logical grouping of infrastructure that shares common failure characteristics.
Lesson 2452 — Fault Domains and Isolation Boundaries
Fault domains
Fault domains are essentially separate server racks with independent power and networking.
Lesson 99 — Azure VM Availability Sets and Zones
Federation
Federation is Prometheus's built-in mechanism for one Prometheus server to scrape and store metrics from another Prometheus server.
Lesson 1961 — Federation for Multi-Cluster Monitoring
Field-based indexing
Only specific structured fields are indexed (faster, smaller, but limited scope)
Lesson 2011 — Log Indexing Fundamentals
file storage
While block storage (from our previous lesson) acts like a raw hard drive attached to one VM at a time, file storage is network-attached and shareable:
Lesson 114 — File Storage OverviewLesson 125 — Block Storage vs Other Storage TypesLesson 140 — Object Storage vs. Block vs. File
File uploads
A new image appears in storage
Lesson 462 — Event-Driven Execution Model
Filter plugins
Filter plugins are the processing stations that clean, parse, and enrich the data
Lesson 2021 — Logstash Architecture and Pipelines
Filtering
Filtering means dropping logs that match certain patterns before they're stored.
Lesson 663 — Log Sampling and FilteringLesson 1443 — Log Sampling and Filtering
Fine-grained access control
Fine-grained access control means granting permissions at the file, folder, or even column level rather than blanket access.
Lesson 2639 — Data Lake Security and Access Control
Firestore
Firestore is the newer generation that comes in two modes:
Lesson 440 — Google Cloud Firestore and Datastore
flapping
Your pods would scale up, then down, then up again—a phenomenon called flapping.
Lesson 1451 — HPA Scaling Behavior
Flexibility
Supports pipelines defined as code (Jenkinsfile), freestyle projects, and complex multi-branch workflows
Lesson 1770 — Introduction to Jenkins and CI/CD Automation
Flow logs
Flow logs are the equivalent for your cloud network—they record traffic metadata about every connection passing through your network interfaces, subnets, or entire virtual networks.
Lesson 213 — Network Security Logging and Monitoring
Fluent Bit
Fluentd is feature-rich and supports extensive plugins, while Fluent Bit is lightweight and optimized for resource-constrained environments—ideal for Kubernetes nodes where efficiency matters.
Lesson 1438 — Fluentd and Fluent BitLesson 2038 — Fluentd and Fluent Bit Overview
Fluentd
Fluentd is feature-rich and supports extensive plugins, while Fluent Bit is lightweight and optimized for resource-constrained environments—ideal for Kubernetes nodes where efficiency matters.
Lesson 658 — Log Collection AgentsLesson 1438 — Fluentd and Fluent BitLesson 2025 — Fluentd vs Logstash Trade-offsLesson 2038 — Fluentd and Fluent Bit Overview
Foreground deletion
Parent waits until all children are deleted first
Lesson 1125 — Owner References and Garbage Collection
Forward compatibility
Forward compatibility means old readers can handle new schemas (usually by ignoring unknown fields).
Lesson 2638 — Schema Evolution and VersioningLesson 2732 — Event Schema Evolution
four or five addresses
Typically, four or five addresses are reserved in every subnet:
Lesson 179 — Reserved IP Addresses in Subnets
Freestyle Projects
Freestyle Projects are the traditional, GUI-based approach.
Lesson 1774 — Freestyle Projects vs Pipeline Jobs
Full ownership
Full ownership means "you build it, you run it." The team that develops a microservice also:
Lesson 2565 — Microservices Team Organization

G

GameDay
A GameDay is a scheduled, controlled chaos testing event where teams intentionally break production-like systems to validate their resilience.
Lesson 2499 — GameDays and Chaos Testing Practices
gauge
A gauge is a Prometheus metric type that represents a single numerical value that can arbitrarily go up or down over time.
Lesson 627 — Metric Types: Counters and GaugesLesson 1950 — Metric Types: Gauge
Geo-blocking
Geo-blocking means preventing access from specific countries or regions entirely.
Lesson 592 — Geographic Restrictions and Content Blocking
GitOps for GitOps
Your Application definitions themselves are version-controlled and reconciled
Lesson 1913 — App of Apps Pattern
Global values
Global values are shared across all charts in the hierarchy—parent and all subcharts.
Lesson 1553 — Subchart Overrides and Global Values
Golden Signals
The Golden Signals are four essential metrics that, when monitored together, give you a complete picture of your system's health.
Lesson 2108 — Golden Signals and Key Metrics
Google Cloud Infrastructure Manager
Google Cloud Infrastructure Manager is Google's modern native IaC solution.
Lesson 946 — Deployment Manager vs Terraform on GCP
graceful shutdown
This is also called graceful shutdown because the transition happens smoothly without dropping traffic.
Lesson 279 — Connection Draining and Graceful Shutdown
Groups
Groups are collections of Users, allowing you to apply permissions to multiple people at once.
Lesson 349 — Groups FundamentalsLesson 1376 — Subjects in RBAC

H

Hardening
Hardening is the process of removing unnecessary features, closing ports, patching vulnerabilities, and configuring systems to minimize attack surface.
Lesson 2843 — Security Baseline and Hardening
Hardware token
A physical device that generates codes or must be inserted (like a USB security key)
Lesson 342 — Multi-Factor Authentication (MFA) Basics
headless service
A headless Service is a special type of Kubernetes Service that doesn't allocate a cluster IP or perform load balancing.
Lesson 1181 — Headless Services for StatefulSetsLesson 1210 — Headless Services
Health checking
The registry must continuously verify service availability across cloud boundaries using cross-cloud network paths you've established (VPNs, interconnects).
Lesson 2784 — Multicloud Service Discovery
Health checks
Health checks are the monitoring system that continuously verifies instance health.
Lesson 289 — Auto Scaling Components
Healthcare
HIPAA mandates how patient data is protected
Lesson 2322 — Introduction to Compliance in Cloud
Helm chart
A Helm chart is Helm's packaging format—a collection of files organized in a specific directory structure that describes a complete set of Kubernetes resources needed to run an application, service, or tool inside a Kubernetes cluster.
Lesson 1522 — Charts: Helm's Packaging Format
Heterogeneous migration
Heterogeneous migration is the challenging cousin: moving data and structure between different database engines.
Lesson 2808 — Heterogeneous Database Migration
Hibernation
Hibernation is like putting your laptop to sleep with all your programs still open.
Lesson 88 — VM Hibernation
Hidden cost drivers
A service cheap in one cloud might have expensive data egress fees when talking to resources in another cloud
Lesson 2757 — Multicloud Challenges: Cost Management and Visibility
homogeneous migration
A homogeneous migration means moving a database from one environment to another while keeping the same database engine (e.g., MySQL to MySQL, PostgreSQL to PostgreSQL, Oracle to Oracle).
Lesson 2807 — Homogeneous Database Migration
Hooks
Hooks are temporary resources that run at specific sync lifecycle points:
Lesson 1911 — Sync Waves and Resource Hooks
Hosted
At a third-party facility, but still dedicated hardware just for you (sometimes called "hosted private cloud")
Lesson 21 — Private Cloud Deployment Model
Hot data exists
A small subset of data gets requested repeatedly (e.g., trending products, user session data)
Lesson 2682 — In-Memory Caching Fundamentals
Hot Storage
Hot Storage (or Standard tier) is optimized for data you access frequently—daily or even hourly.
Lesson 118 — Hot, Warm, and Cold Storage Tiers
HSM-protected keys
HSM-protected keys (Premium tier) are generated, stored, and processed entirely within FIPS 140-2 Level 2 validated Hardware Security Modules.
Lesson 2316 — Azure Key Vault Key Management
HTTP endpoint
The specific path the ALB should request (e.g., /health, /status, /api/ping)
Lesson 251 — Health Check Configuration for ALBs
HTTPS checks
Like HTTP but over TLS. Verifies SSL/TLS endpoints are responding correctly.
Lesson 268 — NLB Health Checks
Human-Readable Syntax
Configuration files use HashiCorp Configuration Language (HCL), which is designed to be clear and maintainable.
Lesson 723 — What is Terraform and Why Use It
hybrid approaches
In cloud environments, hybrid approaches are common.
Lesson 636 — Metric Collection Methods
hybrid cloud
A hybrid cloud is like having both a home office and a coworking space.
Lesson 22 — Hybrid Cloud Deployment Model
Hybrid operations
Hybrid operations is the discipline of managing both environments simultaneously with consistent processes, tooling, and governance during this transition period (which might last months or years).
Lesson 2815 — Hybrid Operations and Coexistence
hypervisor
A hypervisor is the software layer that makes virtualization possible.
Lesson 52 — Hypervisors and Virtualization Types
Hypothesis-driven experimentation
Hypothesis-driven experimentation is at the heart of chaos engineering.
Lesson 2490 — Introduction to Chaos Engineering

I

IaaS
IaaS is like renting an empty building—you install everything yourself
Lesson 18 — Container as a Service (CaaS) Introduction
IAM role
An IAM role is like a security badge that can be worn by different entities (EC2 instances, Lambda functions, other AWS accounts).
Lesson 379 — AWS IAM Roles and Trust Policies
IAM users
IAM users are individual identities you create within your AWS account.
Lesson 377 — AWS IAM Users and Root Account
Idempotency
Idempotency means your workflow can be safely retried without causing duplicate side effects.
Lesson 2528 — Workflow Best Practices
identifier
The identifier is a unique name you choose (like "web_server" or "database").
Lesson 801 — Calling Modules with module Blocks
Identities
Identities are the people with key cards (users, applications, services), and resources are the rooms, equipment, and data they might need to access (databases, storage, virtual machines, networks).
Lesson 333 — IAM Core Concepts: Identities and Resources
identity
An identity is anything that can request access to cloud resources:
Lesson 333 — IAM Core Concepts: Identities and Resources
Identity Federation
Identity Federation means establishing trust relationships between different identity providers (IdPs) and service providers (SPs), allowing users authenticated in one system to access resources in another without re-authenticating.
Lesson 2852 — Identity Federation and SSO
Idle Timeout
Idle Timeout is how long the ALB keeps a connection open when no data flows.
Lesson 252 — ALB Connection Handling and Timeouts
IgnoredDuringExecution
If node labels change after the Pod is running, it stays put
Lesson 1347 — Required Node Affinity Rules
image
The pre-built container image to use (e.g., nginx:latest)
Lesson 1049 — Defining Services in Compose
image digest
An image digest is a cryptographic hash like sha256:a1b2c3d4... that uniquely identifies exact image content.
Lesson 983 — Image Tags vs DigestsLesson 1067 — Image Digests and Immutability
image manifest
An image manifest is a JSON document stored in a container registry that describes everything about an image: its layers, their order, the platform it runs on (OS/architecture), and configuration details.
Lesson 995 — Image Manifest and DigestLesson 1070 — Image Manifest and Layers
image tag
An image tag is a label like nginx:latest or myapp:v1.2.3.
Lesson 983 — Image Tags vs Digests
ImagePullSecret
An ImagePullSecret is a special type of Secret (kubernetes.io/dockerconfigjson) that stores registry credentials in the same format Docker uses.
Lesson 1271 — ImagePullSecrets for Private Registries
ImagePullSecrets
ImagePullSecrets are the native Kubernetes approach.
Lesson 2278 — Container Registry Authentication
Immutable
Immutable means "unchangeable." In cloud architecture, immutable infrastructure is the practice of never modifying infrastructure after it's deployed.
Lesson 46 — Immutable Infrastructure Principles
Immutable audit trails
Log every migration action (database replications, cutover triggers, configuration changes) to support forensic analysis if recovery is needed.
Lesson 2817 — Disaster Recovery During Migration
immutable ConfigMap
An immutable ConfigMap is one that cannot be changed after creation—any updates require deleting and recreating it.
Lesson 1255 — Immutable ConfigMaps
Importing
Importing is the process of telling your IaC tool about resources that already exist, so it can add them to its state file and manage them going forward.
Lesson 706 — Import Existing Resources
Improved reliability
Origin is less likely to become overwhelmed
Lesson 166 — Multipart UploadLesson 591 — Origin Shield and Cache Hierarchies
In-Place Deployment
The application on each instance is stopped, updated with the new version, and restarted — all on the same instances. It's like renovating your house while still living in it. This approach uses existing infrastructure but causes brief downtime during updates. Best for cost-conscious deployments where some downtime is acceptable.
Lesson 1831 — CodeDeploy Overview and Deployment Types
Inbound traffic
Inbound traffic is validated, potentially authenticated via mTLS, and forwarded to the target application
Lesson 1578 — Istio Data Plane and Envoy Proxies
Incident Response Lifecycle
The Incident Response Lifecycle is a framework that breaks down incident management into five distinct stages, each with clear goals and handoffs.
Lesson 2126 — Incident Response Lifecycle
index
An index is a logical collection of similar documents—for application logs, you might have one index per day like logs-2024-01-15.
Lesson 2018 — Elasticsearch Fundamentals for Logging
Indexers
Indexers are Splunk's heart: they receive raw log data, break it into events, and store it in highly compressed, searchable indexes.
Lesson 2042 — Splunk Cloud and Enterprise Logging
Infrastructure as Code
Infrastructure as Code is the practice of managing and provisioning infrastructure using machine-readable definition files instead of manual processes.
Lesson 684 — What is Infrastructure as Code?
Ingress Controller
An Ingress Controller is a Pod running in your cluster that:
Lesson 1221 — Ingress Controller Architecture
IngressClass
IngressClass is like a routing tag that says: "This Ingress resource should be handled by that specific Ingress Controller."
Lesson 1227 — IngressClass Resource
Initial
Sets resources only when Pods are created (not on existing Pods)
Lesson 1456 — VPA Configuration and Policies
Input plugins
Input plugins are the receiving docks where raw materials (logs) arrive
Lesson 2021 — Logstash Architecture and Pipelines
Instance Metadata Service
The Instance Metadata Service is a special internal API that runs inside every cloud environment, allowing your VM to query information about itself.
Lesson 86 — Instance Metadata Service
instance profile
An instance profile is a container that passes IAM role information to an instance at launch time.
Lesson 358 — Instance Profiles and Metadata
instance template
An instance template is a saved configuration that defines everything about a VM—machine type, disk image, network settings, metadata, and startup scripts.
Lesson 103 — GCP Instance Groups and Templates
Instance Type
The instance family and size (e.g., "t2.micro")
Lesson 86 — Instance Metadata Service
Instant recovery
Failed instances are replaced without data loss concerns
Lesson 2474 — Designing for Stateless-First Architecture
Instant scalability
The engine automatically scales to handle concurrent users and query complexity without pre-configuration.
Lesson 2656 — Serverless Query Engine Overview
Instant vector
A set of time-series containing a single sample per series at one moment in time. Query: http_requests_total returns the most recent value for each unique label combination.
Lesson 1962 — PromQL Basics and Data Model
instant vector selector
An instant vector selector is a PromQL query that returns a set of time series with a single sample value per series—essentially a snapshot of "right now." You specify which metrics you want by combining a metric name with optional label matchers to filter down to exactly the data you need.
Lesson 1963 — Instant Vector Selectors
Instrumentation
Instrumentation means adding monitoring code directly into your applications using Prometheus client libraries.
Lesson 1954 — Exporters and Instrumentation
Instrumentation overhead
Instrumentation overhead is the performance tax you pay for distributed tracing—the difference between your application's throughput and latency with and without tracing enabled.
Lesson 2071 — Instrumentation Overhead
Integration
Integration means bringing build statuses, deployment pipelines, metrics, logs, and traces directly into your developer portal—typically platforms like Backstage—so teams see everything in one place.
Lesson 2934 — Integrating CI/CD and Observability
Internal Developer Platform
An Internal Developer Platform (IDP) is a curated layer of tools, workflows, and abstractions that sits between developers and the underlying infrastructure.
Lesson 2914 — Internal Developer Platform (IDP) Fundamentals
internet gateway
An internet gateway is a managed cloud component that allows resources inside your Virtual Private Cloud (VPC) to communicate with the internet.
Lesson 187 — Internet Gateway Fundamentals
IP aliasing
Unlike legacy route-based clusters, VPC-native clusters assign IP addresses directly from your VPC's subnet ranges using a feature called IP aliasing.
Lesson 1480 — GKE Networking Fundamentals
IPC namespace
Inter-process communication resources (like message queues) are isolated between containers.
Lesson 963 — Process Isolation with Namespaces
Isolation boundaries
Isolation boundaries are the strategic separations you create between fault domains.
Lesson 2452 — Fault Domains and Isolation Boundaries
Issuer
The trusted identity provider URL (e.g., https://accounts.google.com)
Lesson 1627 — JWT Authentication and Validation
issues
Triggers when issues are opened, edited, closed, labeled, etc.
Lesson 1701 — Repository and Issue Event Triggers
Items
Items are individual records in a table (like spreadsheet rows).
Lesson 430 — DynamoDB: Fundamentals and Data Model

J

Jaeger
A CNCF project designed for distributed tracing. Configure your OTel Collector or SDK with an OTLP exporter pointing to Jaeger's OTLP receiver (typically port 4317 for gRPC or 4318 for HTTP).
Lesson 2085 — Integrating OTel with Tracing Backends
Jaeger Agent
A lightweight daemon deployed alongside your services that batches and forwards spans to collectors
Lesson 2089 — Jaeger Overview
Jenkins Master
Think of it like a construction site: the Jenkins Master (controller) is the project manager who assigns tasks, while Agents (workers) are the crews who actually build things.
Lesson 1771 — Jenkins Architecture: Master and Agents
Jenkins Plugin Manager
The Jenkins Plugin Manager is your central hub for discovering and installing these extensions.
Lesson 1775 — Jenkins Plugins and Extensibility
Jenkins X
Jenkins X is an opinionated CI/CD platform built around GitOps for Kubernetes.
Lesson 1863 — GitOps Tooling Landscape
job
In GitLab CI/CD, a job is a single unit of work—a specific task your pipeline executes, like compiling code, running tests, or deploying an application.
Lesson 1686 — Jobs and Job DependenciesLesson 1702 — Jobs: Definition and DependenciesLesson 1730 — Defining Your First JobLesson 1742 — Jobs and Stages Definition
Job definitions
Job definitions are named blocks that specify work to be done.
Lesson 1741 — GitLab CI/CD Pipeline File Structure
Jobs
While Deployments and DaemonSets keep pods running continuously, Jobs are designed for tasks that need to run to completion and then stop—think data processing, batch calculations, or one-time migrations.
Lesson 1191 — Kubernetes Job Resource Fundamentals
jobTemplate
The Job specification to create (identical to standalone Job manifests)
Lesson 1196 — CronJob Resource Fundamentals
JSON
JSON is human-readable and flexible but inefficient for analytics.
Lesson 2632 — File Formats for Analytics
JSON parsing
If logs are already JSON-formatted, extract nested fields automatically
Lesson 660 — Log Parsing and Enrichment
Jumbo frames
Jumbo frames are packets larger than the standard 1,500-byte MTU—typically 9,000 bytes or 9,001 bytes.
Lesson 2229 — MTU and Jumbo Frames

K

Kafka Streams
Kafka Streams is a lightweight Java library embedded directly in your application—no separate cluster needed.
Lesson 2611 — Stream Processing Frameworks
Key
The path within the bucket where your state file will be stored
Lesson 115 — Object Storage OverviewLesson 785 — Configuring S3 Backend
key policy
A key policy is a JSON document attached directly to a KMS key.
Lesson 2310 — AWS KMS Key Policies and Grants
key ring
A key ring is a logical grouping container for cryptographic keys in a specific location.
Lesson 2318 — GCP Cloud KMS Structure and Key Rings
Keys
Keys are unique identifiers for each object within a bucket.
Lesson 141 — Objects, Buckets, and Keys
Keyspaces
Keyspaces are managed cloud services that offer Apache Cassandra-compatible databases without requiring you to install, patch, or maintain Cassandra clusters yourself.
Lesson 443 — Keyspaces and Cassandra-Compatible Services
Kiali
Kiali is the topology-focused dashboard for service mesh.
Lesson 1634 — Service Mesh Dashboards
Kind
Think of it like a library catalog system: the resource type is the URL path you use to access items (like /books or /magazines), while the Kind is the formal classification appearing on the item itself (like "Book" or "Magazine" on the cover).
Lesson 1119 — Resource Types and Kinds
kube-apiserver
The kube-apiserver is the only component that directly talks to etcd (the cluster's database) and serves as the entry point for all administrative tasks.
Lesson 1101 — Control Plane Components IntroductionLesson 1102 — API Server: The Cluster Gateway
kube-controller-manager
The automation engine. It runs multiple controllers that watch the cluster state and work to make reality match your desired configuration (like maintaining the right number of replicas).
Lesson 1101 — Control Plane Components Introduction
kube-scheduler
The matchmaker. When a new pod needs to run, the scheduler picks the best worker node for it based on resource availability and constraints.
Lesson 1101 — Control Plane Components Introduction
kubelet
You've learned that the kubelet is the agent running on each worker node, responsible for managing containers.
Lesson 1110 — Container Runtime Integration
Kustomize Controller
The Kustomize Controller is the applier for Kustomize overlays.
Lesson 1932 — Flux Controller Architecture
KV v1
Think of it like a secure filing cabinet: KV v1 is a single drawer where updating a document destroys the old version, while KV v2 is a multi-drawer system that keeps historical copies of every document you file.
Lesson 2261 — Key-Value Secrets Engine
KV v2
Think of it like a secure filing cabinet: KV v1 is a single drawer where updating a document destroys the old version, while KV v2 is a multi-drawer system that keeps historical copies of every document you file.
Lesson 2261 — Key-Value Secrets Engine

L

labels
Key-value pairs you attach for organization, selection, and grouping. Unlike the other fields, labels are flexible and user-defined (e.g., app: frontend, env: production). Controllers and selectors use labels to find and manage related objects.
Lesson 726 — HCL Syntax FundamentalsLesson 1121 — API Object MetadataLesson 1123 — Labels and SelectorsLesson 1153 — Pod Labels and AnnotationsLesson 1955 — Labels and DimensionalityLesson 1962 — PromQL Basics and Data ModelLesson 2144 — GCP Labels for Cost Tracking
Labels on PersistentVolumes
Labels on PersistentVolumes are key-value pairs you add to describe attributes:
Lesson 1300 — Volume Selectors and Labels
Lambda authorizer
A Lambda authorizer is a function you write that API Gateway calls before routing requests.
Lesson 544 — API Gateway Authorization Strategies
Language independence
A single sidecar implementation works across microservices written in Python, Java, Go, or any language.
Lesson 2599 — Sidecar Pattern for Cross-Cutting Concerns
latency
Think of your cloud network like a highway system: latency is how long it takes one car to get from point A to B, throughput is how many cars can travel per hour, and packet loss is how many cars mysteriously disappear en route.
Lesson 10 — Edge Locations and Points of PresenceLesson 446 — Database Performance Metrics and MonitoringLesson 1599 — Cilium Service Mesh with eBPFLesson 2185 — Latency and Performance MetricsLesson 2226 — Bandwidth vs Throughput vs Latency
Latency matters
Sub-millisecond response times are critical
Lesson 2682 — In-Memory Caching Fundamentals
Latency vs Consistency
Synchronous cross-region replication ensures consistency but increases latency; asynchronous improves speed but means different regions see events at different times
Lesson 2737 — Multi-Region Event Distribution
launch template
Your launch template is like a blueprint or recipe that defines what to create when scaling up.
Lesson 289 — Auto Scaling Components
Layer digests
The cryptographic hashes (SHA-256) identifying each layer in order
Lesson 980 — Image Manifest and Metadata
Layers
Layers are reusable packages of libraries, dependencies, or configuration files that you can attach to your functions.
Lesson 484 — Custom Runtimes and LayersLesson 1070 — Image Manifest and Layers
Lazy Evaluation
Only compute expensive attributes when a span is actually sampled.
Lesson 2071 — Instrumentation Overhead
Lazy Loading
The Cache-Aside pattern (also called Lazy Loading) is a caching strategy where your application code is responsible for both reading from the cache and loading data into it.
Lesson 2697 — Cache-Aside (Lazy Loading) Pattern
Lease ID
A unique identifier for that specific secret instance
Lesson 2265 — Vault Leases and Revocation
Least privilege
Least privilege means Terraform gets only the permissions required to read, write, and lock state files—nothing more.
Lesson 212 — Least Privilege Network AccessLesson 793 — Backend IAM and Access ControlLesson 1246 — NetworkPolicy Best Practices
Least Privilege Principle
The Least Privilege Principle means giving identities (users, groups, roles, or services) only the permissions they absolutely need to perform their job—and nothing extra.
Lesson 368 — Least Privilege Principle
License-included
License-included means the cloud provider bundles the software license with the infrastructure.
Lesson 2162 — License Optimization
Lifecycle
They start together, stop together, and are scheduled on the same node.
Lesson 1148 — Multi-Container Pods
Lifecycle hooks
Lifecycle hooks are designated checkpoints where you can run custom scripts to prepare servers, validate deployments, or perform cleanup tasks.
Lesson 318 — ASG Lifecycle HooksLesson 1834 — CodeDeploy Lifecycle Hooks
Lifecycle Independence
A PV's lifecycle is decoupled from Pods. Delete a Pod, and the PV remains—protecting your data from accidental loss.
Lesson 1289 — PersistentVolume (PV) Fundamentals
Lifecycle policies
Lifecycle policies are automated rules that define when and which images should be removed from your registry.
Lesson 998 — Image Retention and Cleanup Policies
Limit blast radius
if one zone is compromised, attackers can't freely move laterally
Lesson 2841 — Security Boundaries and Trust Zones
Limits
Limits are the maximum you can use — a ceiling that prevents your container from consuming excessive resources and starving others.
Lesson 1329 — Understanding Resource Requests and LimitsLesson 2984 — Container Cost Optimization
linear pipeline
A linear pipeline is the simplest and most straightforward CI/CD pattern.
Lesson 1657 — Linear Pipeline Pattern
list
A list is like a numbered grocery list—an ordered collection of items you access by position.
Lesson 734 — Lists and Maps in HCL
listener
A listener is a process that monitors a specific port and protocol combination on your load balancer.
Lesson 243 — Load Balancer Listeners and RulesLesson 246 — ALB Listeners and Rules
literal Secret
A literal Secret means you provide the sensitive data (passwords, tokens, keys) directly on the command line as key-value pairs, without needing a YAML file or external file.
Lesson 1261 — Creating Secrets from Literals
load balancer
A load balancer is like a traffic cop directing cars to multiple identical toll booths—it focuses purely on distributing incoming requests evenly across healthy servers.
Lesson 231 — What is Load Balancing?Lesson 521 — API Gateway vs Load Balancer
Load Balancer Probes
If your VMSS is behind a load balancer, those health checks (pinging specific endpoints) signal VMSS about instance health. If a VM fails probes consistently, VMSS knows something's wrong.
Lesson 324 — VMSS Health Monitoring and Automatic Repairs
load balancing algorithm
That rule is called a load balancing algorithm or distribution method.
Lesson 240 — Load Balancing Algorithms
Load balancing algorithms
Load balancing algorithms are the decision-making strategies that determine this distribution.
Lesson 1614 — Load Balancing Algorithms
local route
A local route is automatically created when you build a VPC.
Lesson 181 — Default Routes and Local Routes
Locality-aware load balancing
Locality-aware load balancing is a traffic management feature that prioritizes routing requests to service instances in the same zone or region as the caller before attempting more distant locations.
Lesson 1615 — Locality-Aware Load Balancing
location
The Azure region where the resource deploys (e.g., eastus, westeurope). Some resources are global and don't need this.
Lesson 895 — Resource Declarations in ARM Templates
Lock ID
A unique identifier for the stuck lock
Lesson 795 — Handling State Lock Failures
log
A log is a timestamped record of a discrete event that happened in your system.
Lesson 652 — What Are Logs and Why They Matter
log aggregation pipeline
A log aggregation pipeline is like a postal sorting facility for your logs.
Lesson 665 — Log Aggregation Pipelines
Log Analytics workspace
A Log Analytics workspace is a centralized repository in Azure where all your logs and performance data are stored and analyzed.
Lesson 676 — Azure Log Analytics Workspaces
Log correlation
Log correlation means connecting related log entries that belong to the same logical operation, even when they're written by different services at different times.
Lesson 2012 — Log Correlation and Context
Log Explorer
Log Explorer is the interactive interface for searching and analyzing your logs.
Lesson 681 — Cloud Logging in GCP
Log indexing
Log indexing is the process of creating data structures that act like a book's index—allowing you to jump directly to relevant logs instead of reading every line.
Lesson 2011 — Log Indexing Fundamentals
Log levels
Log levels are standard categories that classify how urgent or significant a log entry is—like labeling emails as "urgent," "normal," or "FYI."
Lesson 653 — Log Levels and Severity
Log parsing
Log parsing means breaking those raw strings into individual fields (like timestamp, severity, user ID, or error message).
Lesson 660 — Log Parsing and Enrichment
log router
The log router is the central hub that receives all logs.
Lesson 681 — Cloud Logging in GCP
Log sinks
Log sinks are routing rules that tell the log router where to send logs.
Lesson 681 — Cloud Logging in GCP
Logs
Timestamped records of discrete events (errors, user actions, system changes). These are like your car's maintenance history—detailed records of what happened when.
Lesson 49 — Observability and Monitoring ArchitectureLesson 674 — Azure Monitor Overview
Long polling
Long polling is like waiting at your mailbox for up to, say, 20 seconds.
Lesson 564 — Long Polling vs Short Polling
Loose coupling
Loose coupling means designing your cloud systems so that individual components (services, applications, databases) interact with minimal dependencies.
Lesson 41 — Loose Coupling and Service Independence
Lost
The bound PV no longer exists
Lesson 1291 — PV and PVC Binding Process
Low Latency
Because blocks are accessed directly by address, block storage delivers high IOPS and low latency—perfect for performance-sensitive applications.
Lesson 113 — Block Storage Overview
Lower CPU utilization
The network adapter handles more work, freeing your CPU for application tasks
Lesson 2231 — Enhanced Networking and SR-IOV
Lower runner costs
Less compute time means lower GitHub Actions usage
Lesson 1719 — Caching Dependencies and Build Artifacts

M

Machine type
The VM size (e.g., e2-medium, n1-standard-4, n2-highmem-8). This determines CPU cores and memory.
Lesson 1479 — GKE Node Pools and Machine Types
Maintainability
Smaller templates are easier to test, debug, and update
Lesson 907 — Linked Templates and Template Nesting
Maintenance window
A weekly time slot (e.g., "Sundays 2:00–3:00 AM UTC") when updates can occur
Lesson 413 — Maintenance Windows and Updates
Maintenance windows
Maintenance windows are scheduled time blocks where alarm evaluation is paused for selected resources or groups.
Lesson 413 — Maintenance Windows and UpdatesLesson 648 — Alarm Suppression and Maintenance Windows
Managed identities
Managed identities are Azure's solution: they give your Azure resources (like Virtual Machines, App Services, or Functions) an automatic identity in Azure Active Directory.
Lesson 389 — Azure Managed Identities
managed node group
A managed node group is Amazon EKS's automated way of provisioning and lifecycle-managing EC2 instances that serve as worker nodes in your cluster.
Lesson 1465 — Creating Managed Node Groups
Managed Node Groups
Managed Node Groups are AWS-operated EC2 instances that EKS provisions, updates, and terminates for you.
Lesson 1464 — EKS Node Groups: Managed vs Self-Managed
Managed rule groups
Managed rule groups are pre-built, vendor-maintained collections (from AWS or marketplace sellers) that protect against common threats like SQL injection, cross-site scripting, or bot traffic.
Lesson 2369 — AWS WAF Rules and Rule Groups
Managing Variables
The /projects/:id/variables endpoint allows you to create, update, or delete CI/CD variables programmatically—useful when credentials rotate or configurations change.
Lesson 1769 — GitLab CI API and Automation
manifest list
A multi-architecture image uses a special construct called a manifest list (or "fat manifest").
Lesson 996 — Multi-Architecture Images
Manifests
Manifests are catalog cards that tell you which boxes (layers) you need and in what order
Lesson 936 — Deployment Manager Architecture and ComponentsLesson 1070 — Image Manifest and Layers
Manual
Manual means Azure won't touch your running instances automatically.
Lesson 323 — VMSS Upgrade Policies and Rolling Updates
manual approval gate
A manual approval gate is a deliberate pause point in your automated pipeline where execution stops until a human reviewer explicitly gives permission to continue.
Lesson 1662 — Manual Approval Gates
manual sync
Think of it like package delivery: manual sync is like requiring a signature—the package (your deployment) sits at your door until you explicitly approve it.
Lesson 1884 — Sync Policies and Manual vs Auto Sync
map
A map is like a dictionary—a collection of key-value pairs where you look up values by their descriptive names.
Lesson 734 — Lists and Maps in HCL
matrix build
A matrix build is like running the same test suite simultaneously across different combinations of variables—imagine testing your Node.js app on versions 14, 16, and 18, across Ubuntu, macOS, and Windows, all at once.
Lesson 1709 — Matrix Builds for Parallel Testing
Max TTL
The maximum duration a lease can be renewed to
Lesson 2265 — Vault Leases and Revocation
Maximum Capacity
The ceiling. Your Auto Scaling group will never scale above this number, no matter how high demand gets. This protects you from runaway costs or resource exhaustion.
Lesson 292 — Minimum, Maximum, and Desired Capacity
Maximum storage limit
The ceiling the database can grow to (prevents runaway costs)
Lesson 401 — Storage Autoscaling
Measuring RTO
Track how long it actually takes from failure detection to full service restoration. If your documented RTO is 5 minutes but testing shows 15, you have a gap to address.
Lesson 2488 — Failover Testing and Validation
Media types
The format of each component (e.g., application/vnd.oci.image.layer.v1.tar+gzip)
Lesson 980 — Image Manifest and Metadata
Memcached
Redis and Memcached are popular examples.
Lesson 2469 — Distributed Caching for Stateful Data
Memory management
Memcached uses a slab allocator with LRU eviction; Redis is more flexible
Lesson 2689 — Memcached Fundamentals
Memory Pressure Eviction
The entire node is low on memory → pods evicted based on priority
Lesson 1341 — OOMKilled and Memory Pressure
Memory security
Keys in RAM are vulnerable to memory dumps
Lesson 2305 — Data Key Caching Pattern
Message
A unit of data or work to be processed
Lesson 550 — Message Queue Fundamentals
Message attributes
Message attributes are extra labels you attach alongside that body, like sticky notes on an envelope.
Lesson 563 — Message Attributes and Metadata
message queue
A message queue is like a post office box for digital messages.
Lesson 550 — Message Queue Fundamentals
Messages
Messages are the units of data being transmitted.
Lesson 2710 — Message Queue Fundamentals Revisited
Meta-arguments
Meta-arguments are special Terraform keywords that work across all resource types to control behavior:
Lesson 729 — Resource Blocks and Meta-Arguments
Metadata
This is the Deployment's identity card. It contains the name, namespace, labels, and annotations that identify and describe the Deployment itself.
Lesson 56 — VM Metadata and User DataLesson 1162 — Deployment Spec Structure
metadata service
The metadata service is a special HTTP endpoint available from inside your EC2 instance at http://169.254.169.254.
Lesson 95 — AWS EC2 User Data and Metadata ServiceLesson 358 — Instance Profiles and Metadata
Metric aggregation
Metric aggregation is the process of combining multiple raw data points into summary statistics over time intervals (like taking 60 one-second measurements and creating a single one-minute average).
Lesson 634 — Metric Aggregation and Resolution
Metrics
Metrics are numeric time-series values representing the state of your system at specific points in time (CPU percentage, memory usage, request counts).
Lesson 489 — Function Logging and Execution InsightsLesson 674 — Azure Monitor Overview
metrics-server
The metrics-server is a cluster-wide service that collects real-time resource usage data from all nodes.
Lesson 1342 — Monitoring Resource Usage
Middleware services
databases, message queues, and caching layers are integrated
Lesson 14 — Platform as a Service (PaaS) Overview
Minimum Capacity
The absolute floor. Your Auto Scaling group will never scale below this number, even during periods of zero traffic. Think of this as your "always-on" baseline.
Lesson 292 — Minimum, Maximum, and Desired Capacity
minus sign
A minus sign means Terraform will destroy an existing resource.
Lesson 772 — Reading Plan Output
mock integration
A mock integration is a fake backend response configured directly in your API Gateway.
Lesson 545 — Mock Integrations and Testing
module
A module is a collection of related resources packaged together.
Lesson 711 — Code Organization and Module Structure
module registry
A module registry is a centralized repository where reusable Terraform modules are stored, cataloged, and versioned.
Lesson 843 — Module Registry and Versioning
Monitoring replica health
Monitoring replica health means tracking:
Lesson 419 — Read Replica Lag and Consistency
Monitoring replication health
Monitoring replication health means actively tracking key indicators of the replication pipeline's performance and integrity, then alerting when thresholds are breached—before users experience impact.
Lesson 2489 — Monitoring Replication Health
Multi-Cloud Aggregation
If you operate across AWS, Azure, and GCP, visibility means bringing all spending into a unified view rather than juggling separate portals.
Lesson 2961 — Cost Visibility Fundamentals
multi-cloud strategy
A multi-cloud strategy means using services from two or more cloud providers at the same time—like running some workloads on AWS, others on Azure, and maybe analytics on Google Cloud.
Lesson 23 — Multi-Cloud Strategy Fundamentals
Multi-container pods
Specify which container's logs you need: kubectl logs <pod-name> -c <container-name>. This is crucial when debugging sidecar configurations or init container failures.
Lesson 1444 — Troubleshooting with Logs
Multi-tenancy
Separate team workloads safely. The backend team's project can only deploy to backend- namespaces, while the frontend team's project is restricted to frontend- namespaces.
Lesson 1894 — Application Projects
Multicloud
Multicloud means using services from two or more cloud providers simultaneously—such as AWS, Azure, and Google Cloud—in a single IT environment.
Lesson 2751 — What is Multicloud and Why Organizations Adopt ItLesson 2752 — Multicloud vs Hybrid Cloud vs Multi-Region
Multicloud backup
Multicloud backup means storing copies of your production data from one cloud (say, AWS) into another cloud's storage service (like Google Cloud Storage or Azure Blob Storage).
Lesson 2788 — Multicloud Backup and Archive
mutating admission webhook
A mutating admission webhook is a custom HTTP callback that intercepts API requests before objects are persisted to etcd.
Lesson 1410 — Mutating Admission Webhooks

N

N+1 redundancy
N+1 redundancy means having one extra unit beyond minimum requirements.
Lesson 2460 — Capacity Planning for High Availability
name
A unique identifier for the resource within the deployment. This name is used to reference the resource elsewhere in the configuration. Typical examples include descriptive labels like webserver-vm or app-data-bucket.
Lesson 746 — Resource Addressing and ReferencesLesson 751 — Referencing Data Source AttributesLesson 895 — Resource Declarations in ARM TemplatesLesson 897 — Parameters in ARM TemplatesLesson 948 — Resource Definition BasicsLesson 1121 — API Object Metadata
Namespace-based separation
Namespace-based separation is your first line of defense.
Lesson 2058 — Multi-Tenancy and Log Isolation
NAT Gateway
A NAT Gateway is a fully managed cloud service that handles Network Address Translation for you.
Lesson 192 — NAT Gateway OverviewLesson 197 — NAT Gateway vs NAT Instance
NAT instance
A NAT instance is simply a regular EC2 instance that you configure to perform network address translation for your private subnet resources.
Lesson 195 — NAT Instance Basics
Network
A group of endpoints that can communicate directly with each other. This is like a private subnet where containers can talk.
Lesson 1041 — Docker Network Architecture
Network ACLs
Network ACLs are your subnet-level boundary guards.
Lesson 210 — Security Groups vs NACLs Use Cases
Network bottlenecks
Consumer acknowledgments are delayed, but producers keep publishing
Lesson 2740 — Understanding Backpressure in Distributed Systems
Network namespace
Containers get their own network stack—separate IP addresses, routing tables, and firewall rules. This is why two containers can both listen on port 80 without conflict.
Lesson 963 — Process Isolation with Namespaces
Network Path Quality
Public internet routes are unpredictable. Use Direct Connect, ExpressRoute, or Dedicated Interconnect for consistent, lower-latency paths between clouds.
Lesson 2789 — Network Performance and Latency Considerations
NetworkPolicy
A NetworkPolicy is a Kubernetes resource that acts like a firewall for your pods.
Lesson 1234 — NetworkPolicy Fundamentals
NGINX Ingress Controller
NGINX Ingress Controller is the most widely adopted option.
Lesson 1230 — Ingress Controller Options
No data loss
Every failed invocation is preserved
Lesson 500 — Dead Letter Queues
No errors or crashes
The application keeps running, but sluggishly
Lesson 1340 — CPU Throttling Behavior
No maintenance burden
the provider handles hardware, updates, and security
Lesson 20 — Public Cloud Deployment Model
no-store
no-store is the true "never cache this" directive.
Lesson 2672 — Cache-Control Headers Deep Dive
node
A build agent (also called a node) is a machine that executes Jenkins jobs.
Lesson 1779 — Jenkins Build Agents and Executors
Node controller
Validates that nodes exist in the cloud and updates node status if cloud VMs are deleted
Lesson 1107 — Cloud Controller Manager
node pool
A node pool is a group of virtual machines in your Kubernetes cluster that share the same configuration—machine type, disk size, labels, taints, and operating system.
Lesson 1479 — GKE Node Pools and Machine TypesLesson 1494 — AKS Node Pools and VM Scale SetsLesson 1508 — Node Pool Management
NodePort
A NodePort is a Service type that extends the ClusterIP functionality by opening a specific port on every node in your Kubernetes cluster.
Lesson 1207 — NodePort Service Type
NoSchedule
NoSchedule is the strictest scheduling rule.
Lesson 1361 — Taint Effects: NoSchedule, PreferNoSchedule, NoExecute
Notary
Notary is the open-source framework that powers Content Trust.
Lesson 1077 — Content Trust and Notary
Notary v1
The original implementation, battle-tested but considered legacy
Lesson 1077 — Content Trust and Notary
Notification Controller
The Notification Controller is Flux's messaging hub that watches for events across all other Flux controllers and sends alerts to external systems.
Lesson 1936 — Notification Controller

O

Object storage
Object storage is like a massive warehouse where each item gets a unique barcode (key) and sits flat on shelves with descriptive tags (metadata).
Lesson 125 — Block Storage vs Other Storage TypesLesson 140 — Object Storage vs. Block vs. File
Objects
Objects are the actual units of data you store—files, images, videos, backups, anything.
Lesson 141 — Objects, Buckets, and Keys
Observability
Observability is your feedback loop—continuously monitoring sync status, detecting when actual infrastructure diverges from Git, and alerting when reconciliation fails to bring things back in line.
Lesson 49 — Observability and Monitoring ArchitectureLesson 1875 — Observability in GitOps
Observability gaps
Understanding what's happening across service boundaries is difficult
Lesson 1576 — Istio Overview and Core Value Proposition
Observability portability
Observability portability means implementing metrics, logs, and traces using open standards that work consistently across AWS, Azure, GCP, or on-premises—without rewriting instrumentation when you change providers.
Lesson 2774 — Observability Portability
offset
Each message within a partition gets a sequential ID called an offset, which consumers use to track their reading position.
Lesson 2608 — Introduction to Apache Kafka
OK
The metric is within acceptable bounds
Lesson 670 — CloudWatch Alarms and Actions
On-Demand Instances
On-Demand Instances are like renting a hotel room by the hour—you pay for what you use with no commitment.
Lesson 94 — AWS EC2 Launch Types and Tenancy
on-demand pricing model
The on-demand pricing model is cloud computing's most flexible payment option.
Lesson 73 — On-Demand Pricing Model
OnFailure
Kubernetes restarts the failed container within the same pod. No new pod is created.
Lesson 1193 — Job Restart and Backoff Policies
OpenTelemetry Collector
The OpenTelemetry Collector is a vendor-agnostic agent that sits between your instrumented applications and your observability platforms.
Lesson 2081 — OpenTelemetry Collector Fundamentals
Operating System Boot Volumes
The root disk where your OS lives typically uses block storage
Lesson 113 — Block Storage Overview
Operating system patches and updates
the platform stays current automatically
Lesson 14 — Platform as a Service (PaaS) Overview
Optimization
Optimization is finding ways to reduce costs without sacrificing performance or reliability.
Lesson 2137 — Cost Management Fundamentals
Optimization blindness
You can't compare apples-to-apples whether a workload would cost less on AWS vs Azure when pricing models are fundamentally different
Lesson 2757 — Multicloud Challenges: Cost Management and Visibility
option group
An option group is a configuration container that lets you turn on specific, optional features for your database engine.
Lesson 404 — Option Groups for Engine Features
Orchestration
A state machine (Step Functions) explicitly defines the forward path and compensation path. Clearer visibility, easier debugging—this is the serverless default.
Lesson 2527 — Saga Pattern in Serverless
Orchestrator Functions
Orchestrator Functions are the heart of the system.
Lesson 2523 — Azure Durable Functions
Ordered deployment and scaling
Pods start sequentially (0, then 1, then 2), ensuring dependencies are satisfied. A database replica won't start before its primary.
Lesson 2470 — Stateful Set Patterns in Kubernetes
Ordered operations
Pods are created in sequence (0, 1, 2...) and terminated in reverse
Lesson 1176 — StatefulSet Fundamentals
OrderedReady
OrderedReady is the cautious, sequential approach:
Lesson 1184 — StatefulSet Pod Management Policies
Ordering
Global ordering is expensive across regions; partition-based ordering (events for the same entity stay ordered) is more practical
Lesson 2737 — Multi-Region Event Distribution
Organization-Level Trails
Cloud providers offer organization-wide logging configurations that automatically capture events from all member accounts without per-account setup. This simplifies management as accounts are added or removed.
Lesson 2354 — Centralized Audit Log Aggregation
origin server
In a CDN, the origin server is your primary server where the original content lives—your application, database, or storage bucket.
Lesson 584 — Origin Servers and Edge Caching
Origin servers
Origin servers are your centralized data centers where the authoritative version of content lives and complex processing happens.
Lesson 611 — Edge vs. Origin: The Request Flow
Origin Shield
Origin Shield is an additional caching layer positioned between your edge servers and origin server, creating a cache hierarchy.
Lesson 591 — Origin Shield and Cache Hierarchies
Orphan deletion
Children are left behind (owner reference removed but objects remain)
Lesson 1125 — Owner References and Garbage Collection
Output plugins
Output plugins are the shipping departments that send finished products (structured logs) to their destinations
Lesson 2021 — Logstash Architecture and Pipelines
Outputs
After your stack is created, outputs expose useful information. You might output the URL of a load balancer, the ID of a created VPC, or the ARN of an S3 bucket. These values can be viewed in the console or referenced by other stacks.
Lesson 859 — CloudFormation Template Anatomy
Over-provisioning
Over-provisioning means paying for capacity you don't use (a 16-core server when 4 cores would suffice).
Lesson 33 — Cloud Cost Optimization: Right-Sizing Resources
Owner references
Owner references are metadata links that establish parent-child relationships between these objects.
Lesson 1125 — Owner References and Garbage Collection

P

PaaS
PaaS is like a fully furnished apartment—just bring your clothes
Lesson 18 — Container as a Service (CaaS) Introduction
packet loss
Think of your cloud network like a highway system: latency is how long it takes one car to get from point A to B, throughput is how many cars can travel per hour, and packet loss is how many cars mysteriously disappear en route.
Lesson 2185 — Latency and Performance MetricsLesson 2225 — Network Performance Metrics and Measurement
PagerDuty
PagerDuty is the industry leader, offering sophisticated alert routing, escalation policies, and deep integrations with monitoring systems.
Lesson 2132 — Incident Management Tools
panel
In Grafana, a panel is the building block of your dashboard—each panel displays data in a specific visual format.
Lesson 1996 — Panel Types and Visualizations
Parallel backups
Maintain independent backup systems for both source and target environments during the migration window. Don't disable legacy backups until cutover is validated and stabilized.
Lesson 2817 — Disaster Recovery During Migration
Parallel Run Approach
Parallel Run Approach means building new Terraform-managed infrastructure alongside legacy systems, testing thoroughly, then cutting over.
Lesson 844 — Migration Strategies for Legacy Infrastructure
parameters
Think of it as a recipe: parameters are your ingredient choices, variables help you calculate measurements, resources are the cooking instructions, and outputs tell you what you made.
Lesson 894 — ARM Template Structure and JSON Syntax
parent layer
Any layer your image builds upon is called a parent layer.
Lesson 978 — Base Images and Parent Layers
Parquet
Parquet is the most popular columnar format for analytics.
Lesson 2632 — File Formats for Analytics
Parsing Efficiency
Parse logs only when necessary. Multi-line parsing and complex regex patterns are expensive—use them selectively on logs that truly need structure.
Lesson 1442 — Logging Performance and Overhead
partition key
A partition key is a single attribute that DynamoDB uses both to identify your item and to decide which physical server (partition) stores it.
Lesson 431 — DynamoDB Primary Keys and Partition KeysLesson 438 — Cosmos DB Partitioning and Request Units
Partition Tolerance
The system continues operating despite network splits
Lesson 2466 — Stateful Services: Challenges and Trade-offs
partitioning
In Cosmos DB, partitioning is how your data spreads across multiple servers for virtually unlimited scale.
Lesson 438 — Cosmos DB Partitioning and Request Units
Path
The URL path Kubernetes requests (e.g., /health, /ready, /api/status)
Lesson 1423 — HTTP Probe Configuration
Path-based
Path-based is easiest to understand and cache.
Lesson 548 — API Versioning Strategies
pd-balanced
The middle ground introduced by Google. SSD-backed but optimized for cost-performance balance. Good for general-purpose workloads that need better performance than standard but don't require the premium price of full SSD.
Lesson 1312 — GCP Persistent Disk StorageClasses
pd-standard
Traditional HDD-backed disks. These are the most cost-effective option for workloads that don't require high performance, like backups, logs, or infrequently accessed data. Lower IOPS and throughput.
Lesson 1312 — GCP Persistent Disk StorageClasses
Pending
Your VM is being created and initialized. Resources are being allocated, the operating system image is loading, and networking is being configured. You can't connect yet.
Lesson 82 — VM States and State Transitions
Performance
Symmetric encryption with DEKs is fast for large data volumes. You can generate unique DEKs per file or per object without overwhelming your KMS.
Lesson 1039 — tmpfs MountsLesson 2282 — Data Encryption Keys (DEK) and Key Encryption Keys (KEK)
Performance isolation
Performance isolation is critical—you don't want "noisy neighbors" affecting your workload
Lesson 108 — GCP Sole-Tenant Nodes
Permanent credentials
Permanent credentials are like having a master key that never expires.
Lesson 341 — Temporary vs Permanent Credentials
permission auditing
Regularly review and remove permissions that are no longer needed—this is called permission auditing.
Lesson 334 — The Principle of Least Privilege
permission boundary
A permission boundary is a special type of IAM policy that defines the maximum permissions an identity (user or role) can ever have—even if other policies grant broader access.
Lesson 369 — Policy Boundaries and Guardrails
Persistence
Memcached is purely in-memory with no persistence; Redis can save to disk
Lesson 2689 — Memcached Fundamentals
Persistent storage binding
PersistentVolumeClaims are created per-pod and survive pod deletion, preserving state even during reschedules.
Lesson 2470 — Stateful Set Patterns in Kubernetes
Physical Distance
The fundamental speed-of-light limit means data traveling from AWS US-East to GCP Europe takes ~80-100ms minimum, regardless of bandwidth. Position workloads geographically close to where they communicate.
Lesson 2789 — Network Performance and Latency Considerations
Physical Tamper Resistance
HSMs are built with sensors that detect physical intrusion attempts. If someone tries to open the device or tamper with it, the HSM erases all stored keys immediately—like a self-destructing safe.
Lesson 2285 — Key Storage and Hardware Security Modules
Pipeline Status Monitoring
Query /projects/:id/pipelines/:pipeline_id to check if a pipeline succeeded, failed, or is still running. External systems can poll this to coordinate multi-system deployments.
Lesson 1769 — GitLab CI API and Automation
placement group
A placement group is a logical grouping of instances within a single availability zone that are physically placed close together on the underlying hardware.
Lesson 2230 — Network Placement Groups
playbooks
Runbooks are step-by-step operational guides for routine tasks (like restarting a service or scaling a database), while playbooks are structured response procedures for specific incident scenarios (like handling a DDoS attack or database corruption).
Lesson 2130 — Runbooks and Playbooks
plus sign
A plus sign means Terraform will create a new resource.
Lesson 772 — Reading Plan Output
Pod
A Pod is the smallest deployable unit in Kubernetes—think of it as a wrapper around one or more containers that need to work closely together.
Lesson 1145 — Pod Definition and Anatomy
Pod Security Admission Controller
The Pod Security Admission Controller is a built-in Kubernetes feature that automatically validates pods against these standards when they're created or updated.
Lesson 1399 — Pod Security Admission Controller
Pod Security Context
A Pod Security Context is a set of security configurations you attach to an entire pod—not just one container.
Lesson 1389 — Pod Security Context Overview
Pod template
The blueprint for creating new Pods (with labels, container specs, etc.)
Lesson 1155 — ReplicaSet Purpose and Architecture
podSelector
Identifies which pods this policy governs using label matching (just like you learned with ReplicaSets and Services). An empty selector {} means "all pods in this namespace."
Lesson 1235 — NetworkPolicy Specification Structure
Policy as Code
Policy as Code is about prevention and enforcement.
Lesson 2336 — Policy as Code vs. Compliance as Code
policy definition
A policy definition is a single rule, like "all storage accounts must enable encryption" or "VMs must be deployed only in specific regions."
Lesson 2343 — Azure Policy for Compliance Automation
Policy libraries
Policy libraries are centralized collections of pre-written, tested compliance policies that multiple teams can import and apply to their infrastructure.
Lesson 2347 — Policy Libraries and Reusability
Policy variables
Policy variables are placeholders in your IAM policies that get replaced with actual values at request time.
Lesson 367 — Policy Variables and Dynamic Policies
policyTypes
An array declaring whether the policy controls Ingress (incoming traffic), Egress (outgoing traffic), or both. Without this field, Kubernetes guesses based on the rules present.
Lesson 1235 — NetworkPolicy Specification Structure
PoP
The physical facility housing infrastructure
Lesson 583 — CDN Architecture and Points of Presence
port
The port number or name (matching the container's port name)
Lesson 1213 — Service Ports and Target PortsLesson 1242 — Port and Protocol Specifications
Port number
The exact port (like 80 for HTTP, 443 for HTTPS, or 3306 for MySQL)
Lesson 1242 — Port and Protocol Specifications
post-build actions
Think of a Jenkins job like cooking a meal: build steps are the actual cooking instructions (chop, sauté, bake), while post-build actions are what you do after cooking (garnish, plate, clean up).
Lesson 1776 — Build Steps and Post-Build Actions
Practical impact
If a user updates their profile on the primary, then immediately refreshes the page (hitting a replica), they might see their old data for a few seconds. For many applications (analytics, reporting, search indexing), this slight delay is acceptable. For critical reads (financial transactions, inventory checks), you must query the primary directly.
Lesson 419 — Read Replica Lag and Consistency
pre-signed URL
A pre-signed URL is a special web address that includes temporary authorization credentials embedded directly in the URL itself.
Lesson 154 — Object URLs and Pre-Signed URLsLesson 165 — Pre-Signed URLs and Temporary Access
pre-warming
For predictable traffic spikes (product launches, major sales events, live broadcasts), pre-warming is critical.
Lesson 281 — Load Balancer Autoscaling and Capacity Planning
PreferNoSchedule
PreferNoSchedule is a soft version of NoSchedule.
Lesson 1361 — Taint Effects: NoSchedule, PreferNoSchedule, NoExecute
Pricing data
The rates applied to your resources
Lesson 2178 — GCP Billing Exports to BigQuery
primary origin
A primary origin is your main content source—typically your production web server or storage bucket.
Lesson 597 — Origin Settings and Failover
primitive types
In Terraform, primitive types are the simplest building blocks for variables—they hold a single, atomic value rather than a collection.
Lesson 756 — Variable Types: Primitives
Principle of Least Privilege
The Principle of Least Privilege means giving users, applications, and services only the minimum permissions they need to perform their specific tasks—nothing more.
Lesson 334 — The Principle of Least Privilege
PriorityClass
A PriorityClass is a cluster-level Kubernetes resource that assigns a numeric priority value to pods.
Lesson 1369 — PriorityClass Resources
private cloud
A private cloud is cloud infrastructure dedicated exclusively to a single organization.
Lesson 21 — Private Cloud Deployment Model
Private connectivity redundancy
Private connectivity redundancy means architecting multiple independent paths so that if one circuit, router, or even an entire data center fails, your traffic automatically reroutes through backup connections without disruption.
Lesson 2220 — Private Connectivity Redundancy
Private Hosted Zone
A Private Hosted Zone is like an internal phone book that only works inside your virtual network.
Lesson 224 — Private Hosted Zones
Private images
Private images are custom snapshots you create from configured VMs for your organization's exclusive use.
Lesson 55 — Public vs Private Images
Proactive monitoring and alerting
Proactive monitoring and alerting is like having sensors that notify you when the temperature starts climbing, giving you time to pull over safely.
Lesson 457 — Monitoring and Alerting for Performance
Process Inspection
Environment variables are visible to any process inspection tool (ps, /proc filesystem). Any user with access to the container can dump all environment variables—including your secrets.
Lesson 2270 — Environment Variables for Secrets
Processing complexity imbalance
A producer sends lightweight JSON messages instantly, while the consumer performs database writes or external API calls
Lesson 2740 — Understanding Backpressure in Distributed Systems
Processing Power
The Collector can batch data for efficiency, sample high-volume traces, enrich spans with additional context, filter sensitive information, and transform data formats before export.
Lesson 2081 — OpenTelemetry Collector Fundamentals
Processing Time
Processing time is simpler and fine for use cases where "when we learned about it" matters more than "when it happened" — like real-time monitoring dashboards.
Lesson 2604 — Event Time vs Processing Time
producer
Think of it like a newspaper: the producer is the journalist who writes a breaking news story (the event), and consumers are all the readers who receive and react to that news—some might share it on social media, others might change their travel plans, and some might simply file it away.
Lesson 568 — Event Producers and Consumers
producers
In event-driven architecture, producers are services or components that detect something meaningful happening and publish an event to notify other parts of the system.
Lesson 568 — Event Producers and Consumers
Progressing
Resources are being created or updated but not yet ready
Lesson 1169 — Deployment Rollout StatusLesson 1885 — Application Health and Sync Status
projects
GCP projects are also natural cost boundaries—billing is always tied to a project.
Lesson 2144 — GCP Labels for Cost Tracking
Promotion
Promotion means moving the artifact forward without modification.
Lesson 1672 — Artifact Lifecycle
properties
A nested block containing all the specific configuration settings for the resource. This is where details like region, machine type, disk size, or network settings are defined—everything that customizes how the resource behaves.
Lesson 895 — Resource Declarations in ARM TemplatesLesson 948 — Resource Definition Basics
Protected deletion
You can only delete them when no resources are using the service
Lesson 357 — Service-Linked Roles
Protocol
The transport protocol — TCP, UDP, or SCTP
Lesson 1242 — Port and Protocol Specifications
Provisioners
Provisioners are escape hatches that let you run scripts or commands during resource creation or destruction.
Lesson 823 — Null Resources and Provisioners
Provisioning
Provisioning is the actual process of allocating and configuring resources.
Lesson 699 — Apply and Provisioning
public cloud
A public cloud is a cloud computing environment where services and infrastructure are owned by a third-party provider (like AWS, Azure, or Google Cloud) and shared among multiple organizations over the internet.
Lesson 20 — Public Cloud Deployment Model
Public images
Public images are pre-configured OS templates maintained and published by cloud providers or verified partners.
Lesson 55 — Public vs Private Images
public subnet
A public subnet is one whose resources can directly communicate with the internet, while a private subnet houses resources that should remain isolated from direct internet access.
Lesson 176 — Public vs Private SubnetsLesson 189 — Public vs Private Subnets
Public subnets
Public subnets are where you place resources that need direct internet access:
Lesson 189 — Public vs Private Subnets
pull-based model
The pull-based model is considered more aligned with GitOps principles because it implements continuous reconciliation (principle #4 we learned earlier).
Lesson 1865 — Pull-Based vs Push-Based GitOps
purging
Cache invalidation (also called purging or clearing) tells the CDN to immediately remove specific cached objects so the next request fetches fresh content from the origin.
Lesson 600 — Cache Invalidation and Purging
Pushgateway
The Pushgateway is a special Prometheus component that acts as a temporary metrics repository.
Lesson 1959 — Pushgateway for Short-Lived Jobs

Q

Quality control
Only tested, reviewed modules are published
Lesson 843 — Module Registry and Versioning
Query
A question about whether something should be allowed
Lesson 2890 — Open Policy Agent (OPA) Introduction
Query Capabilities
KQL (Kibana Query Language) and Elasticsearch queries provide rich, flexible searching across all log content. LogQL trades some flexibility for efficiency, focusing on label-based filtering. Splunk's SPL (Search Processing Language) is powerful but proprietary. Managed solutions often provide easier interfaces but less granular control.
Lesson 2045 — Comparing Logging Solution Trade-offs
query editor
The query editor is like typing free-form text—you write queries directly in the data source's native language (like PromQL for Prometheus).
Lesson 1997 — Query Builder and Query Editor
query model
The query model is the menu board that diners see (reads happen here).
Lesson 574 — CQRS Pattern with Events
Query Rewriting
Query Rewriting means restructuring SQL to achieve the same result more efficiently.
Lesson 449 — Query Optimization Techniques
Query splitting
Large time-range queries are broken into smaller chunks, processed in parallel, and reassembled
Lesson 1984 — Thanos Query and Query Frontend
Queue messages
A task is added to a queue
Lesson 462 — Event-Driven Execution Model
Queued
Workflow is waiting for a runner to pick it up
Lesson 1694 — Workflow Status and Logs
Queues
Queues are the buffer storage that holds messages temporarily.
Lesson 2710 — Message Queue Fundamentals Revisited
Quoted Strings
Quoted Strings are your everyday text values wrapped in double quotes:
Lesson 732 — String Literals and String Interpolation

R

race condition
This is called a race condition, and it's exactly what state locking prevents.
Lesson 786 — State Locking Fundamentals
Random access
Random access means jumping to different locations unpredictably—like flipping through a dictionary to look up specific words.
Lesson 119 — Storage Access Patterns and Workload Types
RDS architecture
The RDS architecture is the kitchen, staff, and storage system working behind the scenes so you can simply order your meal (run queries) without worrying about ingredients, cooking equipment, or cleanup.
Lesson 397 — RDS Architecture and Components
read replica
A read replica is a separate, continuously updated copy of your primary database instance that handles read-only queries.
Lesson 418 — Read Replicas for Scalability
Real-time comparison
Current spending is continuously compared against predictions
Lesson 2987 — Cost Anomaly Detection Systems
Receivers
Receivers are the entry points—they ingest telemetry data from various sources (applications, other collectors, cloud services).
Lesson 2082 — Collector Pipeline: Receivers, Processors, Exporters
reconciliation loop
The reconciliation loop is the heart of GitOps.
Lesson 1869 — GitOps Reconciliation Loop
Recording rules
Recording rules are pre-computed queries that Prometheus evaluates at regular intervals and stores the results as new time series.
Lesson 1957 — Recording Rules
Reduced downtime
Problems caught at 80% capacity are easier to fix than total failures
Lesson 639 — Introduction to Alarms and Alerting
Reduced execution time
Reduced execution time is the most obvious win.
Lesson 1658 — Parallel Execution Pattern
Reducing latency
Images are served from the geographically closest replica
Lesson 1093 — ACR Geo-Replication
Redundancy
Redundancy means running multiple instances of the registry service simultaneously.
Lesson 1071 — Registry High Availability Basics
region
A region is a specific geographic area (like "US East" or "Europe West") where a cloud provider has multiple data centers.
Lesson 9 — Regions and Availability ZonesLesson 785 — Configuring S3 Backend
Regional Consolidation
Since cloud providers log events regionally, aggregation means copying logs from all regions into one central location. You might configure US-East-1, EU-West-1, and Asia-Pacific-1 to all forward to a master log bucket.
Lesson 2354 — Centralized Audit Log Aggregation
Regional Keys with Data Locality
Regional Keys with Data Locality means creating separate keys per region when regulations require it.
Lesson 2308 — Encryption in Multi-Region Architectures
registry
A registry is the service that stores and distributes container images.
Lesson 1061 — Registry vs Repository Terminology
Rego
OPA uses a declarative language called Rego to define policies.
Lesson 2890 — Open Policy Agent (OPA) Introduction
Remote Execution
Remote Execution means terraform apply runs in Terraform Cloud's infrastructure—not your laptop.
Lesson 836 — Terraform Cloud for Team Collaboration
Remote state
Remote state means storing your state file in a centralized, shared location — like an S3 bucket, Azure Blob Storage, or a specialized backend service.
Lesson 703 — Local vs Remote State
Reno
Traditional algorithms like CUBIC work well for most scenarios, while Reno is conservative but predictable.
Lesson 2228 — TCP Performance Optimization
Repeatability
Repeatability means you can destroy and rebuild infrastructure confidently.
Lesson 686 — IaC Benefits: Consistency and Repeatability
replica management
In Kubernetes, replica management means telling your Deployment exactly how many identical pod copies (replicas) you want running at all times.
Lesson 1165 — Replica Management
ReplicaFailure
The rollout encountered problems creating Pods
Lesson 1169 — Deployment Rollout Status
Replicas
Replicas are copies of your primary shards stored on different nodes.
Lesson 2018 — Elasticsearch Fundamentals for Logging
ReplicaSet
A ReplicaSet is a Kubernetes controller that ensures a specified number of identical Pod replicas are always running in your cluster.
Lesson 1155 — ReplicaSet Purpose and Architecture
Replication
Replication is the practice of maintaining multiple copies of your registry data across different storage backends or geographic locations.
Lesson 1071 — Registry High Availability Basics
replication lag
Additionally, replication lag means replicas may serve slightly stale data (eventual consistency), which you explored in state replication and consistency models.
Lesson 419 — Read Replica Lag and ConsistencyLesson 2476 — Primary-Replica ArchitectureLesson 2477 — Replication Lag and Consistency
Reply-To Addresses
The request message specifies which queue the response should be sent to. This can be a dedicated temporary queue for that requester or a shared reply queue where the requester filters by correlation ID.
Lesson 2579 — Request-Reply over Message Queues
Repository
The application name (e.g., webapp, api-service)
Lesson 1064 — Image Naming and Tagging Conventions
Repository name
The path and name identifying the image (e.g., nginx, myorg/myapp)
Lesson 990 — Image Naming and Tagging Conventions
repository server
The repository server is ArgoCD's connection to Git.
Lesson 1878 — ArgoCD Architecture Overview
Request manipulation
Request manipulation means altering incoming HTTP details before they reach your origin:
Lesson 619 — Request and Response Manipulation
Request Routing
The gateway inspects incoming requests and forwards them to the appropriate microservice based on path, headers, or other criteria.
Lesson 2576 — API Gateway Pattern
Requests
Requests are what you reserve — the guaranteed minimum resources the scheduler promises your container will have available.
Lesson 1329 — Understanding Resource Requests and LimitsLesson 2984 — Container Cost Optimization
requiredDuringScheduling
The rule MUST be met when scheduling the Pod
Lesson 1347 — Required Node Affinity Rules
Reserved Instances
Reserved Instances are specific to particular instance types, regions, or even availability zones.
Lesson 2153 — Reserved Instances and Savings Plans
Resilience
If a consumer is down, events wait in the queue
Lesson 567 — Event-Driven Architecture Overview
Resizing
Resizing means switching your VM to a different instance type or size—like upgrading from a t3.small to a t3.large, or changing from a general-purpose type to a memory-optimized one.
Lesson 89 — Instance Resize and Type Changes
Resolution
Resolution refers to the granularity of time intervals at which metrics are stored or queried—higher resolution means more frequent data points, lower resolution means broader time windows.
Lesson 634 — Metric Aggregation and Resolution
Resolvers
These are the serverless functions that fetch data when a GraphQL field is requested. In AppSync, resolvers can directly integrate with DynamoDB, Aurora Serverless, or Lambda functions without writing server code.
Lesson 2537 — Serverless GraphQL APIs
resource
A resource is any cloud asset that can be accessed or managed:
Lesson 333 — IAM Core Concepts: Identities and Resources
resource block
A resource block is Terraform's way of declaring a piece of infrastructure you want to create and manage.
Lesson 729 — Resource Blocks and Meta-ArgumentsLesson 739 — Resource Blocks and the Resource Lifecycle
Resource constraints
The consumer has fewer CPU cores or slower disk I/O
Lesson 2740 — Understanding Backpressure in Distributed Systems
resource group
A resource group is a logical container that holds related Azure resources.
Lesson 904 — Resource Groups and Template Scope
resource type
Think of it like a library catalog system: the resource type is the URL path you use to access items (like /books or /magazines), while the Kind is the formal classification appearing on the item itself (like "Book" or "Magazine" on the cover).
Lesson 1119 — Resource Types and Kinds
Resource-based
A special collection room has a sign on the door: "Only faculty members and researchers may enter." The permission is attached to the room itself, regardless of what your library card says elsewhere.
Lesson 336 — Identity-Based vs Resource-Based Policies
ResourceQuota
A ResourceQuota is like a spending limit on a shared credit card for an entire team.
Lesson 1337 — Resource Quota Basics
resources
This is the mandatory section—the heart of your template. Here you declare every AWS resource you want to create: EC2 instances, S3 buckets, VPCs, etc. Without resources, you have no infrastructure to build.
Lesson 333 — IAM Core Concepts: Identities and ResourcesLesson 391 — GCP IAM Overview and HierarchyLesson 847 — Template Structure and SectionsLesson 859 — CloudFormation Template AnatomyLesson 894 — ARM Template Structure and JSON SyntaxLesson 936 — Deployment Manager Architecture and Components
Resources array
The heart of the file—a list of all managed resources
Lesson 775 — State File Contents and Structure
resourceVersion
A version number tracking changes to the object. Every time the object is modified, this value updates. The API server uses it for optimistic concurrency control and to detect stale data.
Lesson 1121 — API Object Metadata
Response Aggregation
The gateway can call multiple services and combine their responses into one payload, reducing client-side complexity and round trips.
Lesson 2576 — API Gateway Pattern
Response manipulation
Response manipulation means changing what comes back from the origin:
Lesson 619 — Request and Response Manipulation
Restore Testing
Restore Testing is the gold standard: actually restoring data to a test environment and validating functionality.
Lesson 2428 — Backup Validation and Testing
Retain
The resource is preserved after stack deletion. It becomes an orphaned resource you manage manually. Perfect for databases, S3 buckets with important data, or anything you can't afford to lose.
Lesson 852 — Stack Deletion and Retention PoliciesLesson 888 — DeletionPolicy and RetainLesson 2796 — Retire and Retain Strategies
Retention
Retention is how long you keep logs before deleting them.
Lesson 656 — Log Retention and Storage Requirements
Retire
Retire means identifying and decommissioning applications that no longer provide business value.
Lesson 2796 — Retire and Retain Strategies
RoleBinding
A RoleBinding is the employment contract that actually assigns that job description to specific people.
Lesson 1381 — RoleBinding Fundamentals
Rollback capability
Reverting to a previous state means reverting a Git commit
Lesson 1856 — Git as Single Source of Truth
root of trust
The root of trust is critical: if the root key is compromised, everything below it falls.
Lesson 2283 — Key Hierarchy and Root of Trust
root volume
The root volume (boot disk) is typically deleted by default
Lesson 85 — VM Termination and Deletion
rotation
Meanwhile, rotation is the practice of periodically changing secrets (passwords, connection strings, API keys) to limit exposure windows if credentials are compromised.
Lesson 2244 — Azure Key Vault Rotation and Versioning
route table
A route table is like a GPS navigation system for your cloud network.
Lesson 180 — Route Tables Basics
Row Count Validation
The simplest check—compare table row counts between source and target. If customers has 1,000,000 rows in source, it should have exactly 1,000,000 in target.
Lesson 2830 — Data Validation and Consistency Checks
rule
A rule is a logical statement that produces a value.
Lesson 2891 — Rego Language Basics
rule group
A rule group is a collection of these rules bundled together, like a security team with specialized skills.
Lesson 2369 — AWS WAF Rules and Rule Groups
Rules
In AWS WAF, rules are the individual conditions that inspect web requests—think of them as security guards checking for specific threats.
Lesson 1378 — Defining Permissions with RulesLesson 2369 — AWS WAF Rules and Rule Groups
Runbooks
Runbooks are step-by-step operational guides for routine tasks (like restarting a service or scaling a database), while playbooks are structured response procedures for specific incident scenarios (like handling a DDoS attack or database corruption).
Lesson 2130 — Runbooks and Playbooks
Running
The VM is fully operational and actively executing workloads. You can SSH or RDP into it, applications are processing requests, and you're being charged for compute time.
Lesson 62 — VM States: Running, Stopped, TerminatedLesson 82 — VM States and State Transitions
runs
The using: "composite" declaration plus the steps to execute
Lesson 1714 — Composite Actions
runtime environment
A runtime environment is the execution context your function code runs in—it includes the programming language interpreter or compiler, standard libraries, and system dependencies.
Lesson 471 — Function Runtime Environments

S

saga
A saga is a sequence of local transactions where each service:
Lesson 2586 — Saga Pattern for Distributed Transactions
Sampling
Log sampling means capturing only a percentage of logs rather than every single entry.
Lesson 663 — Log Sampling and FilteringLesson 1443 — Log Sampling and FilteringLesson 2056 — Log Sampling and Filtering
Scale-Down Settings
Tune when and how nodes are removed. Key parameters include:
Lesson 1510 — Cluster Autoscaler Configuration
Scale-Up Behavior
Configure how quickly new nodes are added when pods are pending. Parameters like --scale-up-from-zero and --max-nodes-total control this expansion.
Lesson 1510 — Cluster Autoscaler Configuration
Scaling In
Scaling In means removing instances from your fleet.
Lesson 291 — Scaling Out vs Scaling In
scaling oscillation
This is called scaling oscillation, and it's exactly what cooldown periods and warmup times prevent.
Lesson 303 — Cooldown Periods and Warmup
Scaling out
The manager calls in more servers as customers arrive (adding capacity)
Lesson 291 — Scaling Out vs Scaling In
Scaling policy monitoring
Scaling policy monitoring means actively observing how your scaling policies behave in real-world conditions, reviewing their history, and adjusting them based on what you learn.
Lesson 312 — Scaling Policy Monitoring
Schedule
Days and times when syncs are allowed or denied
Lesson 1898 — Sync Windows
schema
A schema is a blueprint that defines what inputs a template expects, their data types, and any constraints.
Lesson 953 — Template Schemas and ValidationLesson 2658 — Athena Data Catalogs and Databases
Schema evolution
Schema evolution is the practice of modifying data structures over time while maintaining compatibility with existing data and consumers.
Lesson 2638 — Schema Evolution and VersioningLesson 2654 — Schema Evolution and Versioning
Scrape interval optimization
Scrape interval optimization is the art of finding the sweet spot for each job.
Lesson 1988 — Scrape Interval Optimization
SDK
The SDK is the implementation of the API.
Lesson 2074 — OpenTelemetry Architecture and Components
Secret Access Key
A private password that must be kept secure
Lesson 343 — Access Keys and Credential Management
secrets
In cloud infrastructure, secrets are sensitive pieces of data that grant access to systems, services, or data.
Lesson 2237 — Introduction to Secrets Management in Cloud
SecretStore
A SecretStore is a custom resource in the External Secrets Operator that defines how to connect to an external secrets provider.
Lesson 1278 — SecretStore Resource
Secure by Default Configuration
Secure by Default Configuration means cloud resources should start their life with the strongest possible security settings automatically enabled—not as an afterthought.
Lesson 2844 — Secure by Default Configuration
Secure Score
A numerical rating of your security posture with prioritized recommendations
Lesson 2863 — Azure Security Center and Sentinel
Security
The KEK stays in a hardware security module (HSM) or cloud KMS and never leaves. Even if encrypted data and encrypted DEKs are compromised, attackers can't decrypt without access to the KEK.
Lesson 1100 — Kubernetes Cluster Architecture OverviewLesson 2282 — Data Encryption Keys (DEK) and Key Encryption Keys (KEK)
security baseline
A security baseline is your organization's defined minimum security configuration for every resource type.
Lesson 2843 — Security Baseline and Hardening
Security boundaries
Prevent accidental or malicious deployments. A project can block certain resource types (like ClusterRoles) or restrict which Git repos are trusted sources.
Lesson 1894 — Application Projects
security boundary
A security boundary is a logical or physical perimeter that separates different levels of trust within your infrastructure.
Lesson 2841 — Security Boundaries and Trust Zones
Security breaches
If an account is compromised, attackers gain only limited access
Lesson 334 — The Principle of Least Privilege
security group
A security group is a virtual firewall that protects individual cloud instances (virtual machines) by controlling which network traffic is allowed to reach them and which traffic they can send out.
Lesson 202 — Security Group Fundamentals
security group chaining
This technique is called security group chaining or security group references, and it's incredibly powerful for building secure, scalable multi-tier architectures.
Lesson 205 — Security Group Chaining and References
Security groups
Security groups are your primary defense tool.
Lesson 210 — Security Groups vs NACLs Use Cases
security policy
A security policy is a collection of rules evaluated in priority order (lowest number first).
Lesson 2371 — Google Cloud Armor Fundamentals
Selector
The label query to find Pods this ReplicaSet manages
Lesson 1155 — ReplicaSet Purpose and Architecture
Selectors
Selectors are queries that find objects based on their labels.
Lesson 1123 — Labels and Selectors
Self-heal
Essential for production environments where Git is the single source of truth
Lesson 1886 — Self-Heal and Prune Options
self-hosted runners
While GitHub-hosted runners (covered in the previous lesson) are convenient and maintained by GitHub, self-hosted runners are machines you manage and configure yourself that execute your GitHub Actions workflows.
Lesson 1690 — Self-hosted Runners Overview
Self-Managed Nodes
Self-Managed Nodes are EC2 instances you provision and maintain yourself, then register with your EKS cluster.
Lesson 1464 — EKS Node Groups: Managed vs Self-Managed
Semantic conventions
Semantic conventions are OpenTelemetry's standardized naming rules for span attributes, metrics, and resource information.
Lesson 2077 — Semantic Conventions and Standard Attributes
Sentinel Imports
Pre-built libraries give you access to Terraform plan data, state, and configuration—letting you inspect proposed resources, check naming conventions, verify tags, or ensure approved AMIs are used.
Lesson 2341 — Terraform Sentinel Overview
Separation of Storage and Compute
You pay for storage and queries separately. Storage costs are low, and compute charges only when queries run—idle data costs nothing to maintain.
Lesson 2636 — Google BigQuery Fundamentals
Sequential access
Sequential access means reading or writing data in a continuous, ordered fashion—like reading a book from start to finish.
Lesson 119 — Storage Access Patterns and Workload Types
Serial Console
Direct connection through the hypervisor → works even when networking is completely broken
Lesson 64 — VM Consoles and Troubleshooting Access
service
A Kubernetes Service is an abstraction layer that provides a stable network endpoint (a consistent IP address and DNS name) for a set of Pods.
Lesson 1049 — Defining Services in ComposeLesson 1203 — Kubernetes Services Overview
service accounts
In GCP, service accounts are non-human identities designed for applications, VMs, and automated processes—not people.
Lesson 393 — GCP Service Accounts
service catalog
A service catalog is a curated collection of ready-to-use platform services, templates, and resources that developers can provision through self-service.
Lesson 2925 — Service Catalog Fundamentals
Service independence
Service independence means each component can be updated, scaled, or even fail without bringing down the entire system.
Lesson 41 — Loose Coupling and Service Independence
Service Key
The critical handoff point between you and your provider
Lesson 2216 — ExpressRoute Circuit Configuration
service map
A service map is a visual representation of how services in your distributed system communicate with each other.
Lesson 2067 — Service Maps and Dependency Graphs
service mesh
A service mesh is a dedicated infrastructure layer that handles service-to-service communication in distributed applications, particularly microservices architectures.
Lesson 1564 — What is a Service Mesh?Lesson 2584 — Service Mesh for Communication ManagementLesson 2769 — Service Mesh for Portability
service principal
A service principal is an identity created for applications, scripts, and automation tools to access Azure resources.
Lesson 390 — Azure Service Principals
Service Principals
Service Principals are application identities that allow automated systems (CI/CD pipelines, build servers) to authenticate without human interaction.
Lesson 1092 — ACR Authentication and RBAC
service-linked role
A service-linked role is a special type of IAM role that AWS services create and manage automatically.
Lesson 382 — AWS Service-Linked Roles
Service-specific
Each role is tied to one service and includes that service in its name
Lesson 357 — Service-Linked Roles
Service-to-Service
A Lambda function's execution role grants access to specific secrets. The function retrieves them via environment variables or direct API calls using its inherited permissions—zero hardcoded passwords.
Lesson 2249 — Cross-Service Secrets Integration
ServiceAccounts
ServiceAccounts are Kubernetes-managed identities for Pods and processes running inside the cluster.
Lesson 1376 — Subjects in RBAC
session affinity
Sticky sessions (also called session affinity) ensure that requests from the same client are consistently routed to the same backend server instance.
Lesson 2467 — Sticky Sessions and Affinity
shadowing
Traffic mirroring, also called shadowing, is a service mesh technique that sends a copy of production traffic to a separate service or version while letting the original request proceed normally to production.
Lesson 1609 — Traffic Mirroring (Shadowing)
sharding
Partitioning and sharding are strategies that divide your data across multiple storage units to improve performance and scalability.
Lesson 455 — Partitioning and Sharding Strategies
Shared Responsibility Model
The Shared Responsibility Model is the foundational security concept in cloud computing: the cloud provider secures the infrastructure of the cloud, while you secure what you put in the cloud.
Lesson 7 — Shared Responsibility ModelLesson 2842 — Shared Responsibility Model
Shared tenancy
Shared tenancy (default) means your VMs run on physical hardware shared with other AWS customers—but always isolated at the hypervisor level.
Lesson 94 — AWS EC2 Launch Types and Tenancy
Shield Advanced
While AWS Shield Standard provides automatic, free protection against common DDoS attacks, Shield Advanced is a premium service offering enhanced capabilities for mission-critical applications.
Lesson 2382 — AWS Shield Advanced
Shift-Left Enforcement
Policies run during development and CI/CD pipelines—catching violations before resources reach production. This is far cheaper and safer than discovering compliance gaps after deployment.
Lesson 2888 — Policy as Code Fundamentals
Short polling
Short polling is like quickly peeking into your mailbox every few seconds.
Lesson 564 — Long Polling vs Short Polling
Showback
Showback is informational cost reporting.
Lesson 2958 — Showback vs Chargeback
sidecar
A sidecar is a separate container running alongside your application container in the same pod (Kubernetes context).
Lesson 1564 — What is a Service Mesh?Lesson 2008 — Log Shipping Methods
sidecar container
A sidecar container is an additional container running in the same pod as your application, sharing the same volumes and network namespace.
Lesson 1435 — Logging with Sidecar Containers
Sidecar containers
Sidecar containers are the most common use case: a helper container that enhances the main container.
Lesson 1148 — Multi-Container Pods
sidecar injection
Getting that proxy into your pod is called sidecar injection.
Lesson 1579 — Sidecar Injection Mechanisms
Simple Scaling
Simple Scaling is the most basic approach.
Lesson 316 — ASG Scaling Policies in AWS
Simplify deployment
Pre-configure networking so launching new databases is consistent
Lesson 405 — Subnet Groups and Network Placement
single point of failure
A single point of failure is any component in your system whose failure would cause the entire service—or a critical part of it—to stop working.
Lesson 2450 — Single Points of Failure Identification
Single-AZ
Single-AZ is cheaper because you're running one database instance in one location.
Lesson 417 — Multi-AZ vs Single-AZ Trade-offs
Single-User Rotation
The same credentials are updated in place. The service briefly switches from old to new credentials. Simple but has a brief moment where old credentials might be cached.
Lesson 2240 — AWS Secrets Manager Rotation
Size-based retention
Cap total storage per partition (e.g., 1 GB). Once exceeded, the oldest segments are removed.
Lesson 2610 — Kafka Retention and Storage
SLA
An SLA is a contractual promise to customers, often with financial consequences if violated.
Lesson 2112 — Service Level Terminology: SLI, SLO, and SLA
SLI
An SLI is a quantitative measurement of a service's behavior — the actual metric you observe.
Lesson 2112 — Service Level Terminology: SLI, SLO, and SLA
SLO
An SLO is your internal target for an SLI — the goal you set for your team.
Lesson 2112 — Service Level Terminology: SLI, SLO, and SLA
SMS code
A text message sent to your phone (less secure, but better than nothing)
Lesson 342 — Multi-Factor Authentication (MFA) Basics
Snapshots
Snapshots are point-in-time copies of a storage volume or virtual machine state, capturing data as it existed at a specific moment.
Lesson 2417 — Backup vs. Snapshot: Understanding the Difference
SNS topic
An SNS topic is a communication channel.
Lesson 557 — AWS SNS Topics and Subscriptions
Software Catalog
The Software Catalog is Backstage's central nervous system—a structured registry that maps your entire software ecosystem.
Lesson 2927 — Backstage Platform OverviewLesson 2928 — Software Catalog in Backstage
Software-protected keys
Software-protected keys are encrypted and processed using Azure's software-based cryptographic operations.
Lesson 2316 — Azure Key Vault Key Management
Source Controller
The Source Controller is one of Flux's core components that acts like a persistent librarian for your infrastructure code.
Lesson 1922 — Source Controller and Git Repositories
span
Each span represents one leg of that journey: a single operation or unit of work with a start time, duration, and outcome.
Lesson 2063 — Spans and Span RelationshipsLesson 2064 — Span Attributes and TagsLesson 2076 — Spans, Traces, and Context Propagation
span IDs
Trace IDs and span IDs are the identifiers that make this possible.
Lesson 2062 — Trace Context and Propagation
Spans
Spans are the individual operations within a trace.
Lesson 2060 — What is Distributed Tracing
spec
This is where you define what you want. The spec contains the deployment's desired state, including how many replicas you want and the deployment strategy.
Lesson 1122 — Object Specifications and StatusLesson 1162 — Deployment Spec Structure
Speed
Binary format is 3-7x smaller than JSON, reducing network overhead.
Lesson 2572 — gRPC for High-Performance Communication
Speed and simplicity
Rehosting is the fastest migration strategy. You avoid time-consuming refactoring or rearchitecting.
Lesson 2792 — Rehost (Lift-and-Shift) Strategy
Spot Instance Fleet Management
Spot Instance Fleet Management means using multiple instance types across availability zones to create a diversified portfolio that reduces interruption risk while maximizing savings.
Lesson 2978 — Spot Instance Fleet Management
SSL offloading
SSL offloading means removing the encryption burden from backend servers.
Lesson 269 — TLS Termination on NLB
stack
Think of AWS CloudFormation like construction: a template is your architectural blueprint (written in JSON or YAML), while a stack is the actual building constructed from those plans.
Lesson 846 — CloudFormation Templates and StacksLesson 877 — Stack Creation and Lifecycle
stack policy
A stack policy is a JSON document that defines update permissions for specific resources, helping you prevent costly mistakes.
Lesson 856 — Stack Policies for Update Protection
StackSet
A StackSet is a container that manages stack instances—actual deployed stacks—across target accounts and regions.
Lesson 883 — StackSets Fundamentals
stages
In Jenkins pipelines, stages are high-level phases like "Build," "Test," and "Deploy"—each representing a distinct purpose.
Lesson 1786 — Stages and Steps Organization
Standard Workflows
Standard Workflows are designed for long-running, auditable processes.
Lesson 2517 — AWS Step Functions Overview
Startup probes
Startup probes are crucial for rolling updates of applications with long initialization times, ensuring Kubernetes doesn't prematurely kill Pods that are still starting up during the transition.
Lesson 1429 — Health Checks and Rolling Updates
state file
A state file is like a detailed inventory list that records every resource the IaC tool has created and their current configurations—databases, servers, networks, storage buckets, and more.
Lesson 700 — Introduction to State Files
State file partitioning
State file partitioning means dividing your infrastructure into multiple independent state files, each managed by a separate Terraform configuration.
Lesson 834 — State File Partitioning
state machine
A state machine is a model that defines a series of states and transitions between them based on conditions or events.
Lesson 2516 — Step Functions and State Machines
State Reconstruction
If your current state (read model, database view) is corrupted or lost, replay all events from the beginning to rebuild it from scratch.
Lesson 2731 — Event Replay and Reprocessing
State Synchronization
The replica must monitor the primary's health and coordinate takeover to prevent split-brain scenarios (both thinking they're primary).
Lesson 1802 — Jenkins High Availability Architecture
Stateless components
Stateless components are HA-friendly because:
Lesson 2461 — Stateless vs Stateful: Core Definitions
Statement
An array containing one or more permission rules. Each statement is like a single rule in your security rulebook.
Lesson 361 — Policy Structure and Syntax
status
The status describes the observed state—what Kubernetes actually sees in the cluster right now.
Lesson 1122 — Object Specifications and Status
Steady State Hypothesis
The Steady State Hypothesis is your definition of how a healthy system behaves under typical conditions.
Lesson 2492 — Steady State Hypothesis
Steady-state rate
The sustained number of requests allowed per second
Lesson 531 — Throttling and Rate Limiting
step
A step is the smallest unit of work in a GitHub Actions workflow.
Lesson 1687 — Steps and Running Commands
steps
Within each stage, steps are the individual commands or actions that execute sequentially to complete that phase.
Lesson 1786 — Stages and Steps Organization
Sticky identity
If Pod db-1 fails, the replacement Pod is still called db-1 with the same storage
Lesson 1176 — StatefulSet Fundamentals
sticky sessions
Session affinity (also called sticky sessions) is a load balancer feature that "remembers" which backend server handled your first request, then routes all your subsequent requests to that same server for the duration of your session.
Lesson 242 — Session Affinity (Sticky Sessions)Lesson 278 — Session Affinity and Sticky Sessions
Stopped
The VM is shut down but preserved. Think of it like sleep mode on your laptop—your configuration and storage remain intact, but no compute resources are consuming power. You pay only for storage.
Lesson 62 — VM States: Running, Stopped, TerminatedLesson 82 — VM States and State Transitions
Stopping
The VM is shutting down gracefully. The operating system is saving state, closing connections, and unmounting volumes. This is a transition state.
Lesson 82 — VM States and State Transitions
storage backend
The storage backend is where Vault persists encrypted data.
Lesson 2253 — Vault Architecture and Components
Storage classes
Storage classes are different tiers of object storage, each optimized for specific access patterns and cost structures.
Lesson 148 — Storage Classes Introduction
storage layer
The storage layer is where your actual data lives.
Lesson 397 — RDS Architecture and Components
Storage size
The PV must have at least the capacity requested by the PVC
Lesson 1291 — PV and PVC Binding Process
StorageClass
A StorageClass is a Kubernetes resource that defines how storage should be dynamically provisioned when a PersistentVolumeClaim (PVC) requests it.
Lesson 1303 — StorageClass Fundamentals
strangler fig pattern
Named after a fig plant that grows around a host tree and eventually replaces it, the strangler fig pattern is the gold standard for microservices migration.
Lesson 2569 — Microservices Migration StrategiesLesson 2598 — Strangler Fig Pattern for Migration
stream
A stream is an ordered sequence of data records (logs, clicks, IoT sensor readings, database changes) continuously flowing through a service.
Lesson 2511 — Stream Processing Pattern
String Interpolation
String Interpolation is where the magic happens.
Lesson 732 — String Literals and String Interpolation
Strong consistency
Strong consistency means cache reads always return the most recent write.
Lesson 2709 — Cache Consistency and Trade-offs
subject
In Kubernetes RBAC, a subject is the "who" in access control — the entity requesting permission to perform an action.
Lesson 1376 — Subjects in RBAC
subnet group
A subnet group is essentially a collection of subnets (network segments) that you've pre-approved as possible locations for your database instances.
Lesson 405 — Subnet Groups and Network Placement
Subscriptions
Subscriptions are how applications receive messages from a topic.
Lesson 562 — Google Cloud Pub/Sub
Subsequent identical requests
Subsequent identical requests are served directly from cache
Lesson 536 — API Gateway Caching
Symmetric encryption
Symmetric encryption (like AES) is blazingly fast but requires safely sharing the secret key with the recipient.
Lesson 2307 — Hybrid Encryption for Large Data
Synchronous invocation
Synchronous invocation means the caller waits for your function to complete and receives the response immediately.
Lesson 487 — Function Invocation TypesLesson 506 — AWS Lambda: Event Sources and Triggers
System metadata
System metadata is created automatically by the cloud provider.
Lesson 142 — Object Metadata and Custom Attributes
System-assigned managed identities
System-assigned managed identities are tied directly to a single Azure resource.
Lesson 389 — Azure Managed Identities

T

Tables
Tables are the top-level containers (like spreadsheet files).
Lesson 430 — DynamoDB: Fundamentals and Data Model
tabletop exercise
A tabletop exercise is a discussion-based session where your DR team walks through disaster scenarios step-by-step, talking through what they would do rather than actually doing it.
Lesson 2904 — Tabletop Exercises
Tabletop exercises
Tabletop exercises are discussion-based walkthroughs where your team reviews the DR plan step-by-step without touching production systems.
Lesson 2902 — DR Testing Fundamentals and Objectives
Tag
A version label (e.g., v1.2.3, latest, staging-20240115)
Lesson 990 — Image Naming and Tagging Conventions
tags
Span attributes (also called tags in some systems) are key-value pairs you attach to spans that answer questions like how, who, what parameters, and what outcome.
Lesson 169 — Object Tagging and MetadataLesson 2064 — Span Attributes and Tags
target group
A target group is a logical container that holds one or more backend targets (like EC2 instances, containers, or IP addresses) that receive traffic from your Application Load Balancer.
Lesson 247 — Target Groups Fundamentals
Target metric value
The "sweet spot" you're aiming for
Lesson 327 — MIG Autoscaling Configuration
Target tracking scaling
Target tracking scaling is like cruise control for your cloud infrastructure.
Lesson 298 — Target Tracking Scaling OverviewLesson 316 — ASG Scaling Policies in AWS
targetPort
The port on the Pod where your container application is listening
Lesson 1213 — Service Ports and Target Ports
Task state
In Amazon States Language (ASL), a Task state represents a single unit of work performed by your state machine.
Lesson 2519 — Step Functions Task States
Tax benefits
OpEx is often fully deductible in the year incurred
Lesson 29 — CapEx vs OpEx: Financial Models in Cloud Computing
TCP checks
Opens a TCP connection to verify the port responds. Simplest option—if the connection succeeds, the target is healthy.
Lesson 268 — NLB Health Checks
tcpdump
tcpdump is a command-line tool that captures raw network packets in real-time.
Lesson 2184 — Network Packet Capture Tools
template
Nested inside the spec, this is essentially a Pod specification. It defines the actual containers, volumes, and configuration for the Pods that will be created. The template has its own metadata (with labels) and spec (describing containers).
Lesson 846 — CloudFormation Templates and StacksLesson 883 — StackSets FundamentalsLesson 1162 — Deployment Spec Structure
Template Specs
Template Specs are Azure resources that store your ARM templates directly in Azure.
Lesson 908 — Template Specs for Reusable Templates
Templates
Templates are reusable building blocks within configurations.
Lesson 936 — Deployment Manager Architecture and Components
Temporary credentials
Temporary credentials are like day passes that automatically expire.
Lesson 341 — Temporary vs Permanent Credentials
temporary or ephemeral storage
Any temporary or ephemeral storage is permanently lost
Lesson 85 — VM Termination and Deletion
Terminated
The VM is permanently deleted. All associated resources (except explicitly preserved volumes) are released. This is irreversible.
Lesson 62 — VM States: Running, Stopped, TerminatedLesson 82 — VM States and State Transitions
Terraform
Industry Standard: Standard Terraform is highly recommended for multi-cloud and GCP deployments, offering a wider ecosystem of providers compared to the historically GCP-only scope of Deployment Manager.
Lesson 723 — What is Terraform and Why Use ItLesson 935 — Introduction to Google Cloud Deployment Manager
Terraform module
A Terraform module is a container for multiple resources that are used together.
Lesson 798 — What Are Terraform Modules
Terraform provider abstraction
Terraform provider abstraction means creating modules that act as translation layers—you define what you want (a compute instance with certain specs) once, and the module handles the how for each cloud provider.
Lesson 2767 — Terraform Provider Abstraction
Terraform version
The exact version of Terraform used
Lesson 775 — State File Contents and Structure
Test in Non-Production First
Deploy to dev/test resource groups before touching production. ARM's incremental mode helps, but testing is irreplaceable.
Lesson 919 — ARM Template Best Practices and Validation
testing pyramid
The testing pyramid is a proven software testing philosophy applied to Infrastructure as Code.
Lesson 2876 — Testing Pyramid for Infrastructure
They're portable
The same container image works everywhere
Lesson 968 — Immutable Infrastructure Pattern
Think of it like
A library where 90% of book requests are already on the shelf versus needing to order from another location.
Lesson 589 — CDN Performance Metrics
Threats
Threats are active attempts to compromise your systems—like credential stuffing attacks, API abuse, or malware deployment.
Lesson 2860 — Threat Detection Fundamentals
Threshold
The trigger value (> 70%)
Lesson 322 — VMSS Scaling Policies and Rules
Throttling
The manager limits how many orders are accepted per minute based on kitchen capacity
Lesson 2748 — Throttling and Circuit Breaker Patterns
throughput
Think of your cloud network like a highway system: latency is how long it takes one car to get from point A to B, throughput is how many cars can travel per hour, and packet loss is how many cars mysteriously disappear en route.
Lesson 2185 — Latency and Performance MetricsLesson 2225 — Network Performance Metrics and MeasurementLesson 2226 — Bandwidth vs Throughput vs Latency
tilde
A tilde means Terraform will update a resource in-place.
Lesson 772 — Reading Plan Output
Time Window
The evaluation period (last 5m, 1h, etc.)
Lesson 2016 — Log Alerting Basics
Time-based code
A 6-digit number from an authenticator app that changes every 30 seconds
Lesson 342 — Multi-Factor Authentication (MFA) Basics
Time-based partitioning
Time-based partitioning is most popular:
Lesson 2661 — Athena Partitioning Strategies
Time-range partitioning
Time-range partitioning is essential since traces are time-series data.
Lesson 2097 — Query Performance and Indexing
timeout
A timeout is a maximum wait duration for a request.
Lesson 1611 — Timeouts and Retry PoliciesLesson 1988 — Scrape Interval Optimization
TLS termination
TLS termination is the process of decrypting HTTPS traffic at the Ingress Controller, then forwarding unencrypted HTTP traffic to backend services.
Lesson 1225 — TLS Termination with Ingress
tmpfs mount
A tmpfs mount is a special type of Docker mount that stores data directly in your host machine's memory (RAM), never writing to the host's filesystem or the container's writable layer.
Lesson 1039 — tmpfs Mounts
token bucket algorithm
The token bucket algorithm is a rate limiting technique that uses a bucket holding tokens.
Lesson 2745 — Token Bucket Algorithm
Tokens
The fundamental auth method. Every successful authentication generates a token that grants access. You can also create tokens directly for testing or automation.
Lesson 2256 — Vault Authentication Methods Overview
toleration
A toleration is a property you add to a pod specification that says "I can tolerate this specific taint." When the scheduler sees a tainted node, it checks if the pod has a matching toleration.
Lesson 1360 — Introduction to Taints and Tolerations
Tolerations
Tolerations are like those special passes that specific pods carry, allowing them to schedule on tainted nodes despite the restriction.
Lesson 1360 — Introduction to Taints and Tolerations
topic
A topic is a logical channel or category for your streaming data.
Lesson 2608 — Introduction to Apache Kafka
Topics
Topics are named resources where publishers send messages.
Lesson 562 — Google Cloud Pub/Sub
topology key
A topology key is a node label that defines the scheduling domain or "grouping" for these rules.
Lesson 1353 — Topology Keys in Affinity
trace ID
A trace ID is a unique identifier (typically 16 or 32 hex characters) generated when a request enters your system.
Lesson 2062 — Trace Context and Propagation
Traceability
Every change is recorded with who made it, when, and why (commit messages). You can trace any deployment back to a specific commit.
Lesson 1647 — Version Control as the Source of Truth
Traceroute
Traceroute is your diagnostic flashlight that illuminates this journey, revealing each hop along the way.
Lesson 2227 — Network Path Analysis and Traceroute
Traces
The journey of a single request through your distributed system. Imagine following one pizza delivery from order to doorstep across multiple services.
Lesson 49 — Observability and Monitoring Architecture
Track usage
See which templates are deployed where
Lesson 908 — Template Specs for Reusable Templates
Traffic Distribution
A global load balancer (DNS-based like Route 53 or a service mesh) directs users to the best-performing or geographically closest cloud provider. Health checks continuously monitor each environment.
Lesson 2759 — Multicloud Architecture Patterns: Active-Active
Traffic Flow Control
Segmentation lets you define explicit allow/deny rules between zones. Your web tier can talk to your application tier on specific ports, but your application tier cannot initiate connections back to the internet. Every cross-segment communication is intentional and logged.
Lesson 2390 — Network Segmentation Fundamentals
Transformations
Transformations are Grafana's post-query processing tools that let you manipulate data after it's retrieved but before it's displayed.
Lesson 1999 — Transformations and Data Processing
Transit Gateway
A Transit Gateway is a regional network transit hub that connects your VPCs, VPN connections, and Direct Connect/ExpressRoute gateways through a single managed gateway.
Lesson 2208 — Transit Gateway for Hybrid Networks
Transitions
Transitions are the connections between stages.
Lesson 1838 — CodePipeline Architecture and Components
Transparent Roadmap
Share what the platform team is building so developers can align contributions or propose alternatives. Use public issue trackers and project boards.
Lesson 2944 — Inner Source and Contribution Models
trigger
Think of it like a smart mailbox: the trigger is the sensor that detects new mail arrival (starting your function), and bindings are the automated sorting system that places incoming mail on your desk and takes outgoing mail to the post office—all without you walking to the mailbox yourself.
Lesson 511 — Azure Functions: Bindings and Triggers
Trunk-Based Development
Trunk-Based Development means developers commit small, frequent changes directly to a single main branch (the "trunk").
Lesson 1668 — Trunk-Based vs GitFlow Patterns
Trust zones
Trust zones are areas within these boundaries where resources share similar security requirements, risk profiles, and access policies.
Lesson 2841 — Security Boundaries and Trust Zones
Tuples
Tuples are like lists but with a fixed sequence of specific types:
Lesson 818 — Working with Complex Variable Types
type
Identifies what you're creating (e.g., Microsoft.Storage/storageAccounts, Microsoft.Compute/virtualMachines). This is like selecting a product category.
Lesson 726 — HCL Syntax FundamentalsLesson 895 — Resource Declarations in ARM Templates

U

uid
A system-generated, globally unique identifier (UUID). Kubernetes assigns this automatically—you never set it manually. It ensures uniqueness even if you delete and recreate an object with the same name.
Lesson 1121 — API Object Metadata
Ultimate disaster recovery
A complete outage or data corruption at your primary cloud provider won't affect backups stored elsewhere.
Lesson 2788 — Multicloud Backup and Archive
Unstructured logs
Unstructured logs are plain text messages that humans write naturally but machines struggle to parse consistently.
Lesson 654 — Structured vs Unstructured LogsLesson 2006 — Structured vs Unstructured Logs
Until Loop
Repeat activities until a condition is met
Lesson 2650 — ADF Pipeline Activities and Control Flow
Usage-based
Distribute costs proportional to actual consumption metrics (network bandwidth, API calls, pod count). This is most accurate but requires instrumentation.
Lesson 2967 — Shared Cost Allocation
User Data
User data is a script or configuration you provide when launching an EC2 instance.
Lesson 56 — VM Metadata and User DataLesson 95 — AWS EC2 User Data and Metadata Service
user identity
A user identity is a digital representation of a real person within your cloud IAM system.
Lesson 346 — Creating and Managing User Identities
User-assigned managed identities
User-assigned managed identities are standalone resources you create once and can assign to multiple Azure resources.
Lesson 389 — Azure Managed Identities
User-defined tags
User-defined tags are custom key-value pairs you create (e.g., Project=Phoenix, Environment=Production, Team=Data-Science).
Lesson 2142 — Cost Allocation Tags in AWS
Username or email
The unique identifier for this person
Lesson 346 — Creating and Managing User Identities

V

Validate propagation
If using dynamic routing (BGP) or route propagation from VPN/transit gateways, ensure routes are appearing as expected.
Lesson 2190 — Route Table Verification
Validation
The controller checks your manifests for errors before applying them, preventing broken deployments.
Lesson 1923 — Kustomize Controller Fundamentals
variables
While parameters accept input from users at deployment time, variables are values you calculate or define inside your template.
Lesson 926 — Variables and Expressions
vault
A vault is your isolated container with its own access policies and audit logs.
Lesson 2242 — Azure Key Vault Fundamentals
Vault Agent Injector
The Vault Agent Injector is a Kubernetes mutating admission webhook controller that intercepts pod creation requests and automatically injects sidecar containers and init containers into your pods based on annotations.
Lesson 2275 — Vault Agent Injector for Kubernetes
vCPU
A vCPU (virtual CPU) represents a portion of a physical processor core.
Lesson 71 — Instance Size Variations and vCPU Allocation
vector matching
This pairing process is called vector matching.
Lesson 1971 — Vector Matching
Vendor lock-in
Vendor lock-in means the cost and complexity of switching providers becomes prohibitively high because your architecture is tightly coupled to one ecosystem.
Lesson 2753 — Multicloud Benefits: Risk Mitigation and Vendor Lock-In
version
The chart's package version (follows semantic versioning like 1.2.3). This changes when you update the chart's templates or configuration.
Lesson 1535 — Chart.yaml Metadata
Version Control
Since infrastructure is code, you can store it in version control systems (like Git). This gives you a complete history of who changed what, when, and why—just like application code.
Lesson 47 — Infrastructure as Code Philosophy
Version Control for Workflows
Your pipeline definitions are versioned alongside your code. Roll back a broken workflow just like you would code.
Lesson 1682 — What is GitHub Actions and Why Use It
Version your templates
Publish v1.0, then v1.1 as improvements are made
Lesson 908 — Template Specs for Reusable Templates
VirtualService
A VirtualService is Istio's primary configuration resource for controlling how requests are routed to services.
Lesson 1581 — VirtualService Fundamentals
Visibility
Visibility is knowing what you're spending and where.
Lesson 2137 — Cost Management Fundamentals
visualization interface
The visualization interface is your window into the data—the UI where you see service maps, flame graphs, trace timelines, and dependency graphs.
Lesson 2088 — Tracing Backend Architecture
VLAN Attachment
A logical connection that associates a VLAN ID with a specific VPC network. You configure this in Google Cloud Console or via gcloud compute interconnects attachments create.
Lesson 2206 — Interconnect VLAN Attachments
VLAN connections
You must create VLAN attachments (also called VLAN connections) to establish Layer 3 connectivity.
Lesson 2219 — Cloud Interconnect VLAN Attachments
VM Scale Set
A VM Scale Set is a group of identical, load-balanced virtual machines that Azure can automatically increase or decrease based on rules you define.
Lesson 107 — Azure VM Scale Sets Introduction
VM size and image
The template for all instances
Lesson 321 — Azure Virtual Machine Scale Sets (VMSS) Fundamentals
volume snapshot
A volume snapshot is a point-in-time copy of your block storage volume.
Lesson 131 — Volume Snapshots
Volumes
Volumes are the simplest abstraction: directories accessible to containers in a Pod.
Lesson 1288 — Kubernetes Storage Abstractions
VolumeSnapshot
VolumeSnapshot is your actual snapshot request.
Lesson 1320 — Volume Snapshots with CSI
VolumeSnapshotContent
VolumeSnapshotContent represents the actual snapshot stored in your underlying storage system.
Lesson 1320 — Volume Snapshots with CSI
VPC Traffic Mirroring
VPC Traffic Mirroring is like installing a hidden camera on your network highway.
Lesson 229 — VPC Traffic Mirroring
VPN Tunnel Configuration
The tunnel itself needs specific parameters:
Lesson 2199 — VPN Gateway Configuration
Vulnerabilities
Vulnerabilities are weaknesses in your configuration or code that could be exploited—unpatched systems, overly permissive IAM policies, or exposed storage buckets.
Lesson 2860 — Threat Detection Fundamentals

W

war room
A war room is a dedicated virtual (or physical) space where the incident response team gathers to collaborate in real-time.
Lesson 2136 — War Rooms and Collaboration During Incidents
warm pool
A warm pool is a collection of pre-initialized instances that are stopped but ready to quickly resume.
Lesson 296 — Warm-up and Warm Pool Concepts
Warm Standby Pattern
The Warm Standby Pattern is a disaster recovery strategy where you run a continuously operational but scaled-down version of your production environment in a DR region.
Lesson 2433 — Warm Standby Pattern
Warm-up time
Warm-up time is the grace period you configure to tell Auto Scaling: "This new instance needs X seconds to fully initialize before it can handle its full workload." During warm-up, the instance doesn't count toward scaling metrics.
Lesson 296 — Warm-up and Warm Pool Concepts
Watermarks
Watermarks are the mechanism streaming systems use to track progress through event time and decide when it's safe to consider a time window "complete."
Lesson 2606 — Watermarks and Late Data
Webhooks
The repository notifies Jenkins immediately when code is pushed (faster and more efficient than polling). Requires configuring a webhook in GitHub/GitLab pointing to your Jenkins instance.
Lesson 1773 — Jenkins Jobs and Build Triggers
WebSocket
WebSocket is a protocol that keeps a connection open between client and server, allowing both sides to push messages whenever needed—no repeated polling required.
Lesson 254 — WebSocket and HTTP/2 Support
what
Monitoring tells you what is happening (metrics), while logging tells you why (detailed execution traces).
Lesson 535 — API Gateway Monitoring and Logs
Whitelisting
Whitelisting is the "allow-only" approach—you specify which countries can access your content, and everyone else is denied.
Lesson 592 — Geographic Restrictions and Content Blocking
who
Service meshes verify who is talking and encrypt the channel.
Lesson 2401 — Zero Trust for Kubernetes Workloads
Widgets
Widgets are the building blocks of dashboards.
Lesson 673 — CloudWatch Dashboards
Wireshark
Wireshark is a graphical tool that excels at analyzing captured packets.
Lesson 2184 — Network Packet Capture Tools
Worker Nodes
The "muscle" of the cluster. These machines actually run your containerized applications (the containers you've been building with Docker). Each worker node receives instructions from the control plane about which containers to run.
Lesson 1100 — Kubernetes Cluster Architecture Overview
workflow
A workflow is a configurable automated process made up of one or more jobs that run when triggered by an event (like a push, pull request, or schedule).
Lesson 1684 — Workflows and Workflow FilesLesson 2648 — Glue Job Triggers and Workflows
Workflow orchestration
Workflow orchestration is a control plane that coordinates multiple serverless functions, managing:
Lesson 2515 — Workflow Orchestration Fundamentals
workload distribution
Unlike Active-Active or Active-Passive patterns that focus on redundancy, workload distribution means intentionally routing different types of work to different clouds where each excels.
Lesson 2761 — Multicloud Architecture Patterns: Workload Distribution
Workload variability
Workload variability is high (spiky traffic, dev/test environments)
Lesson 2536 — Aurora Serverless
Write-Back
The Write-Behind (also called Write-Back) pattern writes data to the cache immediately and returns success to the client, while persisting that data to the underlying data store asynchronously in the background.
Lesson 2699 — Write-Behind (Write-Back) Caching Pattern
Write-Behind
Data is written to cache immediately and asynchronously persisted to the database later, improving write performance but risking data loss.
Lesson 2594 — Distributed Caching Strategies
Write-Through
Data is written to both cache and database simultaneously, ensuring consistency but adding latency.
Lesson 2594 — Distributed Caching Strategies

X

X-B3-ParentSpanId
The parent span identifier
Lesson 2070 — Context Propagation Standards
X-B3-SpanId
The current span identifier
Lesson 2070 — Context Propagation Standards

Z

Zipkin
An older but widely-adopted tracing system. While Zipkin has its own format, OTel exporters can translate traces automatically or you can use OTLP if Zipkin supports it in newer versions.
Lesson 2085 — Integrating OTel with Tracing Backends