C1000-200 key terms

A distributed computing architecture that pools heterogeneous, loosely coupled servers so workloads can be scheduled across many machines, providing scalability and fault tolerance beyond a single host.

The grid component that receives submitted work, selects a suitable execution unit, and forwards the task for processing, acting as the entry point between clients and compute resources.

A worker process or agent registered with the grid that accepts tasks from the dispatcher, runs them, and returns results; multiple units provide parallel throughput and redundancy.

Logic that decides when and where queued work runs, balancing load and honoring priorities or resource constraints so that no single execution unit becomes a bottleneck.

A periodic signal an execution unit sends to show it is alive; missed heartbeats cause the unit to be marked unavailable and its in-flight work to be reassigned.

Automatic transfer of service from a failed component to a standby one, preserving availability with minimal interruption; typically paired with health checks and shared state.

A design goal of keeping a service reachable despite component failures, achieved through redundancy, health monitoring, and rapid recovery rather than through preventing failures entirely.

A set of nodes configured to work as one logical system, sharing configuration and providing capacity or resilience that a single machine could not deliver alone.

An individual server or member within a cluster or grid; nodes host services, participate in membership protocols, and can be added or removed to change capacity.

Distribution of incoming requests across several backends using algorithms such as round robin or least connections, aiming for even utilization and predictable response times.

A configuration in which successive requests from one client are routed to the same backend, usually via a cookie or source-address hash, so locally cached session state remains valid.

Data describing a user's ongoing interaction, such as authentication and cart contents; where it is stored determines whether requests can be freely balanced across servers.

The ability to increase capacity by adding resources; horizontal scaling adds nodes, while vertical scaling enlarges a single node, each with different cost and complexity tradeoffs.

Copying data or configuration from one node to others so that any replica can serve requests and survive the loss of a peer; consistency depends on how writes propagate.

A fast, usually in-memory store holding frequently used data to reduce latency and backend load; entries must be invalidated or expired to avoid serving stale content.

A duration after which a cached entry, message, or record is considered expired and discarded or refreshed, bounding staleness and reclaiming storage automatically.

The number of messages or tasks waiting to be processed; a rising depth signals that producers outpace consumers and often triggers scaling or throttling decisions.

A flow-control mechanism in which a saturated consumer signals producers to slow down, preventing unbounded queues, memory exhaustion, and cascading timeouts.

The volume of work a system completes per unit of time, such as requests per second; it is distinct from latency, which measures how long an individual operation takes.

The elapsed time between issuing a request and receiving a response, including network transit, queueing, and processing; percentile measures describe its distribution better than averages.

A configured limit on how long a caller waits for an operation before abandoning it; timeouts prevent threads from being held indefinitely by a slow or unreachable dependency.

Re-attempting a failed operation, ideally with backoff and jitter and only for transient errors, so that brief faults are absorbed without amplifying load on a struggling service.

A protective pattern that stops sending calls to a failing dependency after a threshold of errors, allowing it to recover and failing fast instead of piling up blocked requests.

A property whereby repeating the same operation produces the same end state as performing it once, which makes safe retries possible after ambiguous failures.

A unique client-supplied identifier attached to a request so the server can detect duplicates and return the original result instead of performing the action twice.

A unit of work that either completes fully or leaves no effect, typically described by atomicity, consistency, isolation, and durability guarantees across participating resources.

Reverting changes made by an incomplete or failed unit of work so that data returns to its prior consistent state, preserving the all-or-nothing guarantee.

A coordination protocol in which participants first prepare and then commit or abort, giving atomic agreement across multiple resources at the cost of blocking if the coordinator fails.

A front door for service APIs that centralizes routing, authentication, rate limiting, and request transformation, shielding clients from internal service topology.

Capping how many requests a client may make in a window, using techniques such as token buckets, to protect shared capacity and enforce fair use.

An allocated allowance of a resource, such as storage or monthly calls, that a tenant may consume; exceeding it typically triggers throttling or rejection rather than silent overage.

A logically isolated customer or organization sharing infrastructure with others; isolation is enforced through separate identifiers, permissions, and resource limits.

A compact credential issued after authentication and presented on subsequent calls to prove identity and convey claims, often with a bounded lifetime and signature for integrity.

A longer-lived credential used to obtain new short-lived access tokens without asking the user to sign in again; it must be stored and rotated carefully.

A delegation framework that lets a user grant a third-party application limited access to resources without sharing the password, using authorization grants and scoped tokens.

A named permission attached to a token that restricts which operations or resources the bearer may access, limiting the blast radius of a leaked credential.

An authorization model assigning permissions to roles rather than individuals, so users inherit rights through role membership and administration stays manageable at scale.

The principle of granting only the permissions needed for a task and no more, reducing the impact of mistakes, compromised accounts, and overly broad service credentials.

Invalidating a previously issued credential or permission before its natural expiry, essential when a token leaks or a user leaves; short lifetimes reduce reliance on it.