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
- 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
- Artifacts
- In CodePipeline, artifacts are the files or data that move between stages—like compiled code, configuration files, or build outputs.
- Lesson 1734 — Job Artifacts: Passing Data Between JobsLesson 1738 — Cache vs Artifacts: Performance OptimizationLesson 1780 — Workspace Management and Build ArtifactsLesson 1847 — Pipeline Artifacts and Artifact Stores
- 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
- The specific output field you want to access
- Lesson 746 — Resource Addressing and ReferencesLesson 751 — Referencing Data Source Attributes
- 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
- Audit trails
- Compliance and debugging become straightforward—every action is recorded as an immutable fact.
- Lesson 695 — IaC Security and Compliance BenefitsLesson 1868 — Environment Promotion PatternsLesson 2300 — Server-Side Encryption with Customer-Managed KeysLesson 2726 — Event Sourcing Fundamentals
- 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
- 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 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 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 policy
- A bucket policy is a JSON document you attach to a storage bucket to define permissions.
- Lesson 164 — Bucket Policies and Access Control
- 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
- Content exists in the edge cache and is served immediately (fast!)
- Lesson 585 — Cache Hit vs Cache MissLesson 611 — Edge vs. Origin: The Request FlowLesson 2671 — CDN Caching Fundamentals Review
- 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
- 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
- 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
- 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
- Consistency
- Consistency means all environments are built from the same source.
- Lesson 47 — Infrastructure as Code PhilosophyLesson 686 — IaC Benefits: Consistency and RepeatabilityLesson 960 — What Are Containers?Lesson 1608 — A/B Testing and ExperimentationLesson 2888 — Policy as Code Fundamentals
- 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
- 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
- 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
- Kafka Streams is simplest (library); Flink and Spark require cluster management
- Lesson 532 — API Gateway Stages and DeploymentLesson 1160 — Understanding Deployments in KubernetesLesson 2611 — Stream Processing Frameworks
- 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
- 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 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
- 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
- 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
- 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
- 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
- Healthy
- Resource is ready and functioning
- Lesson 1885 — Application Health and Sync StatusLesson 1900 — Health Assessment
- 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
- Confirms rules are configured
- Lesson 1235 — NetworkPolicy Specification StructureLesson 1900 — Health Assessment
- 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
- 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
- Each container's changes are independent
- Lesson 171 — Virtual Network ConceptsLesson 979 — Copy-on-Write Strategy
- 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
- 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
- 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
- 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
- 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
- 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
- A namespace is like a container or folder that groups related metrics together.
- Lesson 633 — Metric Namespaces and Naming ConventionsLesson 669 — CloudWatch Metrics and NamespacesLesson 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 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
- NoExecute
- Existing pods are evicted if they don't tolerate the taint
- Lesson 1360 — Introduction to Taints and TolerationsLesson 1361 — Taint Effects: NoSchedule, PreferNoSchedule, NoExecute
- 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
- 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
- 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
- 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
- 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
- post-install
- Runs after all resources are created and ready
- Lesson 1547 — Chart Hooks and LifecycleLesson 1550 — Helm Hooks for Lifecycle Management
- 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-delete
- Triggers before resources are deleted
- Lesson 1547 — Chart Hooks and LifecycleLesson 1550 — Helm Hooks for Lifecycle Management
- pre-install
- Runs before any chart resources are created
- Lesson 1547 — Chart Hooks and LifecycleLesson 1550 — Helm Hooks for Lifecycle Management
- 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
- 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
- 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
- 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
- release
- Fires when releases are published, edited, or deleted
- Lesson 1525 — Installing a Chart: Basic DeploymentLesson 1701 — Repository and Issue Event Triggers
- 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
- 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
- Reproducibility
- Deployments are identical across environments
- Lesson 995 — Image Manifest and DigestLesson 1647 — Version Control as the Source of Truth
- 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 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- stage
- A stage is a logical grouping that organizes related jobs and controls execution order.
- Lesson 532 — API Gateway Stages and DeploymentLesson 1742 — Jobs and Stages DefinitionLesson 1838 — CodePipeline Architecture and Components
- 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 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
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