Hosting & CloudGlossaryPart 5 of 17
Managed Services Glossary
146 terms from the Hosting & Cloud book's Managed Services part, each defined in a line and linked to the chapter that explains it.
- Ably: a realtime pub/sub service whose building block is the channel, multiplexed over one WebSocket per client, for pushing messages to connected browsers and devices (Managed Queues & Streaming).
- AGPLv3: the network copyleft license whose protection is that modifications must be shared with a service's users; Grafana moved to it, and Elastic and Redis later returned to it (Open Source & the Clouds).
- Amazon MQ: AWS's managed Apache ActiveMQ (and later RabbitMQ) broker speaking JMS, NMS, AMQP, STOMP, MQTT and WebSocket, single-instance or active/standby across zones, billed in broker-hours (Managed Queues & Streaming).
- Amazon MSK: AWS's managed Kafka, sold as provisioned brokers billed per broker-hour plus storage, or as Serverless billed per cluster-hour and partition (Managed Queues & Streaming).
- Apache Software Foundation: the foundation that holds Kafka and Pulsar as Apache 2.0 projects owned by the foundation rather than by a company that could relicense them (Open Source & the Clouds).
- APM: Datadog's application performance monitoring product, priced per host alongside Infrastructure (Observability Platforms).
- Aurora Capacity Units (ACU): the unit Aurora Serverless v2 scales in, in steps of 0.5, where one ACU is about 2 GiB of memory with matching CPU and network (Managed Databases).
- Aurora DSQL: AWS's distributed SQL answer to Spanner with PostgreSQL compatibility, an engine that only a provider controlling the hardware and network can sell (Managed Databases).
- AWS CloudWatch: AWS's built-in monitoring, billed per metric-month, per GB of logs, per alarm and per dashboard on the AWS invoice (Observability Platforms).
- Azure Event Hubs: Azure's log service, selling capacity by tier as throughput units, processing units or dedicated capacity units, with retention that lengthens on higher tiers (Managed Queues & Streaming).
- Azure Monitor: Microsoft's built-in monitoring, priced per GB ingested into Log Analytics with commitment tiers and retention charges (Observability Platforms).
- Azure Service Bus: the enterprise broker as a service: queues, topics whose subscriptions carry filter rules, sessions for FIFO and request/response, scheduled delivery, deferral and duplicate detection (Managed Queues & Streaming).
- Backups and point-in-time recovery: a daily snapshot plus continuously shipped transaction logs, which let a managed database be restored to any second within the retention window (Managed Databases).
- Bookies: the storage nodes of a BookKeeper cluster, which hold each Pulsar topic as a series of append-only ledgers while the brokers stay stateless (Managed Queues & Streaming).
- Bookmark: the token each D1 query carries under the Sessions API, so a replica serves a version at least as new as the session has seen, giving sequential consistency per session (Serverless & Edge Databases).
- BSL (Business Source License): a source-available license that allows non-production use, lets the licensor set an Additional Use Grant, and converts to a named open-source license on its Change Date or after four years (Open Source & the Clouds).
- BYOC (bring your own cloud): a deployment in which the provider's cluster runs in the customer's own cloud account, so the provider bills its fee while the customer's cloud bills the infrastructure (Managed Queues & Streaming).
- Capacity units (Event Hubs): single-tenant capacity sold on the Dedicated tier of Azure Event Hubs (Managed Queues & Streaming).
- Cardinality: the number of distinct series a metric produces across its tag values, measured hourly per metric and tag key so a bill spike can be traced to the tag that caused it (Observability Platforms).
- Cells: groups of brokers spread across zones to which Confluent's Kora pins tenants, bounding how far one tenant's load reaches (Managed Queues & Streaming).
- CKU (Confluent Kafka Unit): Kora's capacity abstraction, with bandwidth, request and connection limits that are comparable across clouds (Managed Queues & Streaming).
- Cloud-native monitoring: monitoring built into a cloud (CloudWatch, Azure Monitor, Google Cloud Observability), already collecting that cloud's signals and billed on its invoice (Observability Platforms).
- Cloud-native relational: a familiar relational engine on the provider's own storage (Aurora, AlloyDB, Azure Hyperscale), with fast failover in exchange for storage no other host offers (Managed Databases).
- Cloudflare D1: SQLite as a service with a single primary and asynchronous read replicas, billed by rows read, rows written and storage, with a per-database size ceiling that pushes customers toward many small databases (Serverless & Edge Databases).
- Cloudflare Queues: Cloudflare's queue, delivering at least once to a consumer Worker and billing per 64 KB operation (Managed Queues & Streaming).
- CNCF: the Cloud Native Computing Foundation, part of the Linux Foundation, which holds Kubernetes, Prometheus, OpenTelemetry, NATS and OpenTofu (Open Source & the Clouds).
- Collection: the first stage of an observability pipeline (an agent on each host, an SDK in each process, or a cloud's own emitters), where host counts come from and where data can be sampled or dropped before billing (Observability Platforms).
- Compute-unit hours: Neon's pricing unit for compute, with plans that cap the compute size and bill each CU-hour used (Serverless & Edge Databases).
- Custom metrics: Datadog metrics the customer defines, included per host up to an allotment and billed beyond it, with each tag combination counting as a separate metric (Observability Platforms).
- Database branch: a copy of a serverless database at a point in history with its own endpoint, compute, quota and bill, modeled as a resource with a parent, a creator and an expiry (Serverless & Edge Databases).
- Dead-letter queue: the queue a message moves to after a configured number of failed attempts; target and attempt count are a pair, and each move is an event the customer can alert on (Managed Queues & Streaming).
- Delayed open source: licenses (BSL, FSL) that restrict competing services until a change date and then convert to an open-source license (Open Source & the Clouds).
- Delivery semantics: a queue's guarantee, stored as a column (at least once, deduplicated with its window, or transactional), so documentation, console and support state exactly what was sold (Managed Queues & Streaming).
- Deno KV: a key-value store backed by FoundationDB in production, offering strong or eventual consistency per read and billed in read and write units (Serverless & Edge Databases).
- Diskless Topics: KIP-1150, led by Aiven and accepted by the Kafka community, which keeps topic data in object storage with no broker replication (Managed Queues & Streaming).
- Distributed Processing Units (DPU): the unit Aurora DSQL bills reads and writes in, alongside storage (Managed Databases).
- Distributed SQL: the provider's own engine replicated across zones or regions with strong consistency (Spanner, DSQL, Cosmos DB), and with no other host to move to (Managed Databases).
- Durable Objects: Cloudflare's single-threaded actors, each with a globally unique name, one location and strongly consistent SQLite storage, for state such as a game session, a rate limiter or a document being edited (Serverless & Edge Databases).
- DynamoDB: AWS's fully managed key-value database, descended from the Dynamo paper, whose original pricing unit was provisioned throughput per table (Managed Databases).
- Dynatrace Platform Subscription: an annual platform-level commitment drawn down at rate-card prices, with overage at the same rates (Observability Platforms).
- Edge key-value: keys and values cached or replicated globally (Workers KV, Deno KV, Upstash): simple, global and cheap to read, with eventual consistency as the usual cost (Serverless & Edge Databases).
- Embedded replicas: Turso's feature that serves reads from a local replica inside the application's own process while writes go to the cloud primary (Serverless & Edge Databases).
engine_versions: the table that holds the engine support calendar (end of standard and extended support, the forced-upgrade date, the target version) with the date each was announced (Managed Databases).- Enhanced fan-out: a Kinesis option that gives each registered consumer its own per-shard read throughput pushed over HTTP/2, instead of sharing the shard's read limit (Managed Queues & Streaming).
- Event bus: rule-based routing of events (EventBridge, Event Grid), with native events from the cloud's own services and a per-event cost (Managed Queues & Streaming).
- Event-based SaaS: observability on wide events with columnar queries (Honeycomb), with no cardinality penalty and fast ad hoc questions (Observability Platforms).
- EventBridge: AWS's event bus: events from AWS services, SaaS partners and the customer's own code are matched against rules and routed to targets (Managed Queues & Streaming).
- Fair queues: an SQS feature that uses
MessageGroupIdon standard queues so one queue can be shared among many tenants without one starving the rest (Managed Queues & Streaming). - FIFO queues: SQS queues that add exactly-once processing with a
MessageDeduplicationIdand per-group ordering byMessageGroupId(Managed Queues & Streaming). - Forced upgrade: the provider announcing a date and upgrading whatever engine versions are left in a maintenance window, which is what the end of extended support becomes (Managed Databases).
- Full-stack SaaS: observability platforms (Datadog, New Relic, Dynatrace) that take agents or OTLP and integrate everything, at a bill driven by hosts, bytes and series (Observability Platforms).
- Functional Source License (FSL): Sentry's fixed-term version of the BSL, permitting anything except a "Competing Use," with each release converting to open source after two years (Open Source & the Clouds).
- Google Cloud Observability: Google's built-in monitoring, billed per GiB of logs, per MiB of metrics, per million Prometheus samples and per million spans (Observability Platforms).
- Google Cloud Pub/Sub: one Google service for queues, fan-out and short-retention logs, where a topic has subscriptions that each act as a queue, billed by bytes rather than requests (Managed Queues & Streaming).
- Grafana Cloud: Grafana Labs' managed open-source observability stack, priced by active series for metrics and by GB processed, written and retained for logs, traces and profiles (Observability Platforms).
- Hard-fail limit: a free-tier limit that makes queries fail when reached (as with D1, KV and Hyperdrive), trading a surprise bill for an outage the customer may not have planned for (Serverless & Edge Databases).
- Head sampling: deciding whether to keep a trace at its start, for example by trace-ID ratio; cheap and consistent, but unable to keep every trace with an error (Observability Platforms).
- High availability (Multi-AZ): a hot standby in a second zone fed by synchronous replication, with DNS flipped to it on failure (Managed Databases).
- Honeycomb: an event-based observability platform built for high-cardinality queries, priced by events per month with unlimited seats and custom fields (Observability Platforms).
- Hyperdrive: Cloudflare's service that places a connection pool in regions closest to the origin database and caches non-mutating query results for Workers (Serverless & Edge Databases).
- I/O-Optimized: an Aurora cluster configuration with no per-I/O charge and higher instance and storage rates, for customers who can't forecast I/O (Managed Databases).
- Idle cost: what a database bills when nobody uses it; idle D1 costs nothing, idle Turso only storage and suspended Neon compute nothing, against a provisioned instance billing every hour (Serverless & Edge Databases).
- Inactivity pause: a free project suspended after a period without activity (Supabase after a week, Neon compute after minutes), modeled as a resource in a stopped state (Serverless & Edge Databases).
- Infrastructure (Datadog): Datadog's per-host monitoring product, in Pro and Enterprise tiers that include a pooled allotment of custom metrics (Observability Platforms).
- Ingest: the observability stage where the platform's endpoint receives telemetry, applies the customer's drop and transformation rules, and meters what remains, which makes the rules a pricing feature (Observability Platforms).
- Ingest versus index: the split every observability platform converged on, billing data received separately from data indexed for query so customers can keep data they rarely read cheaply (Observability Platforms).
- Input gates: the Durable Objects mechanism that delivers no new events to an object while its storage operations run, making a single-threaded object correct without locks (Serverless & Edge Databases).
- Instance class: the vCPU and memory size a customer picks when provisioning a managed database, along with storage type and size, engine version and network placement (Managed Databases).
- Kafka-compatible engines: engines that speak the Kafka protocol on a different implementation (Redpanda, WarpStream, Event Hubs, Ursa), for simpler operations or object-storage economics (Managed Queues & Streaming).
- Kinesis Data Streams: AWS's managed log for real-time streaming data, whose unit of capacity is the shard (Managed Queues & Streaming).
- Kora: Confluent's multi-tenant Kafka engine, with tiered storage, CKUs, tenants pinned to cells and dynamic quotas (Managed Queues & Streaming).
- Ledgers: the append-only segments in which BookKeeper stores each Pulsar topic, with sealed segments copied to object storage by tiered storage (Managed Queues & Streaming).
- libSQL: an open-contribution, MIT-licensed fork of SQLite that keeps the single-writer model and adds embedded replicas and remote access (Serverless & Edge Databases).
- Linux Foundation: the foundation where the forks from the relicensing fights landed (Valkey, OpenTofu, the OpenSearch Software Foundation), so no single company can relicense them (Open Source & the Clouds).
- LiteFS: Fly.io's open-source replicated SQLite, running in production but pre-1.0 and offered without support (Serverless & Edge Databases).
- Log (messaging): a shape in which any consumer reads messages at its own offset and messages are kept until retention expires, ordered per partition or shard (Kafka, Kinesis, Event Hubs) (Managed Queues & Streaming).
- Log is the database: Aurora's design principle that only redo log records cross the network, with storage nodes producing pages from them in the background and on demand (Managed Databases).
- Maintenance window: the weekly window a customer picks for minor-version patches and OS updates, with a failover to the standby on Multi-AZ, and forced application when the provider deems a patch mandatory (Managed Databases).
- Managed broker: a protocol broker run for the customer (Amazon MQ, CloudAMQP, Service Bus Premium), speaking AMQP, JMS or MQTT for existing applications (Managed Queues & Streaming).
- Managed Kafka: a provisioned or serverless Kafka log run by a provider (Confluent, MSK, Aiven), offering replay, retention and the Kafka ecosystem (Managed Queues & Streaming).
- Managed key-value: a partitioned key-value store, provisioned or on-demand (DynamoDB), with predictable latency at any scale and no servers to run (Managed Databases).
- Managed open-source engine: a provider-run open-source engine on attached storage (RDS, Cloud SQL, Flexible Server, Aiven, DigitalOcean), the portable middle option (Managed Databases).
- Managed open-source stack: a vendor running open-source observability engines (Grafana Cloud, Elastic Cloud), so data formats stay open (Observability Platforms).
- Messaging unit: the hourly capacity unit of Azure Service Bus Premium, bought in fixed sizes with no per-operation charge (Managed Queues & Streaming).
- Metal: PlanetScale's databases on locally attached NVMe drives with unlimited I/O, at the cost of fixed-size drives that go read-only when full until resized (Serverless & Edge Databases).
- Metrics without Limits: Datadog's split of metric billing into tag combinations ingested and tag combinations indexed for query, so customers can send fine-grained tags without indexing them all (Observability Platforms).
- NATS: a light, fast, edge-friendly messaging system of subjects plus JetStream for persistence, sold by Synadia or self-hosted (Managed Queues & Streaming).
- Neki: PlanetScale's Postgres sharding system, built by the Vitess team and not a fork of Vitess (Serverless & Edge Databases).
- Neon: serverless Postgres with storage separated from compute, billed in compute-unit hours and GB-months of storage (Serverless & Edge Databases).
- Network copyleft: licenses (AGPLv3) that allow running the software as a service but require a modified version to offer its source to users interacting with it remotely (Open Source & the Clouds).
- Nile: Postgres that virtualizes tenants inside one database, each functioning as its own virtual database without Row Level Security (Serverless & Edge Databases).
- Non-compete source-available: licenses (RSALv2, Elastic License 2.0, Confluent Community License, BSL with an Additional Use Grant, FSL) that forbid offering the software as a competing service (Open Source & the Clouds).
- Open core: an open edition of the engine plus a commercial edition with paid features, which protects the features but not the engine (Open Source & the Clouds).
- OpenSearch: AWS's fork of Elasticsearch 7.10 after Elastic's 2021 relicensing, now held by the OpenSearch Software Foundation under the Linux Foundation (Open Source & the Clouds).
- OpenSSF: the Open Source Security Foundation, which holds OpenBao, the Vault fork, for the security and continuity of critical projects (Open Source & the Clouds).
- OSI: the Open Source Initiative, whose position is that source-available licenses are not open source and "fauxpen" labels mislead (Open Source & the Clouds).
- Output gates: the Durable Objects mechanism that holds outgoing messages until a write completes, so no client sees a result that could still be lost (Serverless & Edge Databases).
- Pageserver: the Neon component that materializes page versions from base images plus WAL, asynchronously, and serves pages to compute on request (Serverless & Edge Databases).
- Permissive license: licenses (MIT, BSD-3, Apache 2.0) that allow running the software as a service for others with no obligation to share changes (Open Source & the Clouds).
- Pipelines (telemetry): components that drop, aggregate and route telemetry before it is billed, such as the OpenTelemetry Collector, Grafana Alloy and Chronosphere's Telemetry Pipeline (Observability Platforms).
- PlanetScale: managed MySQL (on Vitess) and Postgres priced by cluster size per month, with a Metal option on local NVMe (Serverless & Edge Databases).
- Processing units (Event Hubs): the Premium-tier capacity unit of Azure Event Hubs, isolated at the CPU and memory level (Managed Queues & Streaming).
- Product retirement: a provider ending an entire deployment option, as Azure did with Azure Database for MySQL Single Server, so every customer on it must migrate (Managed Databases).
- Protection group: a 10 GB Aurora storage segment replicated six ways, small enough to repair quickly so a second failure rarely hits the same segment (Managed Databases).
- Provisioned throughput: DynamoDB's original pricing and isolation unit, in which customers specify the request capacity a table needs and the service reserves it (Managed Databases).
- Provisioned versus used storage: the meter choice between billing what a customer allocated (RDS) and what it consumes (Aurora), which decides whether deleting a table lowers the bill (Managed Databases).
- Pub/sub topic or bus: a shape that delivers each message to every subscription, each of which then acts as a queue (SNS, EventBridge, Pub/Sub) (Managed Queues & Streaming).
- Pulsar: a messaging system of stateless brokers over BookKeeper storage that offers queue and log semantics in one, with multi-tenancy built into topic names (Managed Queues & Streaming).
- Pusher: a realtime pub/sub service (Pusher Channels) sold by daily message and concurrent-connection allowances (Managed Queues & Streaming).
- Query (observability): the stage of dashboards, alerts and ad hoc queries, which some platforms bill directly, for example by data scanned (Observability Platforms).
- Queue: a shape in which each message goes to one of many competing consumers and is deleted once processed (SQS, Service Bus queues, RabbitMQ queues, Cloudflare Queues) (Managed Queues & Streaming).
- Queue in the application's database: a jobs table read with
SKIP LOCKED, which adds no new system and enqueues transactionally, at limited throughput (Managed Queues & Streaming). - R2: Cloudflare's S3-compatible object storage with no egress fee, which Workers read as a data source (Serverless & Edge Databases).
- RabbitMQ under Broadcom: RabbitMQ kept its Mozilla Public License 2.0, and what changed under Broadcom was support, with core-team support limited to commercial customers and contributors and each release given an End of Community Support date (Managed Queues & Streaming).
- RDS Extended Support: a paid option to keep running a major engine version past the end of standard support for a limited time, after which the provider upgrades the database itself (Managed Databases).
- Read replicas: asynchronous copies of a managed database for read scaling, each a separately billed instance, with replica lag the customer has to handle (Managed Databases).
- Realtime channel: a shape that delivers messages to connected clients subscribed to a channel, kept only for a short history (Ably, Pusher) (Managed Queues & Streaming).
- Redpanda: a Kafka-compatible engine under the Business Source License, whose Additional Use Grant forbids offering a competing streaming or queueing service (Managed Queues & Streaming).
- Safekeepers: the Neon nodes that replicate the write-ahead log with Paxos; a transaction commits once a quorum of safekeepers acknowledges its WAL record (Serverless & Edge Databases).
series_counts: the table written hourly per metric name with the distinct count per tag key, so a bill increase can be explained by the tag that caused it (Observability Platforms).- Serverless Postgres: Postgres with separated storage or managed plans (Neon, Supabase, PlanetScale, Xata) that can scale to zero (Serverless & Edge Databases).
- Service-source license: licenses (SSPL) that allow running the software as a service only if the provider releases the source of its whole service stack (Open Source & the Clouds).
- Shard: the unit of Kinesis capacity, with fixed write and read throughput limits per shard (Managed Queues & Streaming).
- SNS: AWS's fan-out service, where a publish to a topic is delivered to every subscription (SQS queues, Lambda functions, HTTP endpoints, email, Firehose) (Managed Queues & Streaming).
- Spanner: Google's globally distributed, synchronously replicated database, the first to offer externally consistent distributed transactions at global scale through an API that exposes clock uncertainty (TrueTime) (Managed Databases).
- SQLite as a service: one file per database with a single writer and replicas (D1, Turso), which makes many small databases nearly free (Serverless & Edge Databases).
- SSPL (Server Side Public License): MongoDB's license whose Section 13 requires anyone offering the program as a service to release the source of the whole service stack, in practice a cloud's control plane; internal use is not a service (Open Source & the Clouds).
- Standard queues: SQS queues that deliver at least once, possibly more than once, with best-effort ordering and nearly unlimited throughput (Managed Queues & Streaming).
- Storage tiers (observability): where telemetry is kept by kind: metrics in a time-series database keyed by series, logs in a search index or a cheaper archive, traces and events in their own stores (Observability Platforms).
- Supabase: Postgres plus REST, auth, realtime and storage around it, priced as a plan plus compute add-ons, disk, monthly active users and egress (Serverless & Edge Databases).
- Tail sampling: deciding whether to keep a trace after seeing most of its spans, so errors and slow traces are kept; stateful and harder to run than head sampling (Observability Platforms).
- Throughput unit (Event Hubs): the Basic and Standard tier capacity unit of Azure Event Hubs, with fixed ingress and egress limits per unit (Managed Queues & Streaming).
- Trademark policy: protecting a project's name regardless of its license, which proved decisive for Elastic and NATS but needs registration and enforcement (Open Source & the Clouds).
- Turso: SQLite (libSQL) as a service with embedded replicas in the application, read-your-writes for the writer and sync for others (Serverless & Edge Databases).
- Upstash: a vendor of Redis-protocol storage priced per command and reachable over HTTP from functions that can't hold a TCP connection (Serverless & Edge Databases).
- Upstash QStash: serverless messaging and scheduling that sits between a producer and an API: QStash calls the destination URL, retries on failure, and supports delays and cron schedules (Managed Queues & Streaming).
- Upstash Redis: a serverless Redis-protocol store reached over HTTP or TCP, per region with read regions, billed by commands, storage and bandwidth (Serverless & Edge Databases).
- Upstash Vector: Upstash's per-request vector index product (Serverless & Edge Databases).
- Ursa: StreamNative's Kafka-compatible data streaming engine built on lakehouse storage (Managed Queues & Streaming).
- Valkey: the Linux Foundation fork of Redis launched after Redis left the BSD license, which AWS and Google ship at lower prices than their Redis caches (Open Source & the Clouds).
- Vendor's own cloud: the engine's maker running it on a hyperscaler (MongoDB Atlas), giving the real engine and newest versions across clouds (Managed Databases).
- Visibility timeout: the SQS lease that hides a received message while the consumer works on it; if the message isn't deleted before it expires, it becomes visible again for redelivery (Managed Queues & Streaming).
- WarpStream: a Kafka-compatible engine, bought by Confluent, that writes directly to S3 from agents in the customer's own cloud account, avoiding stateful brokers and broad vendor access to that account (Managed Queues & Streaming).
- Weak copyleft: licenses (MPL 2.0) that allow running the software as a service but require a covered file distributed in executable form to be made available as source (Open Source & the Clouds).
- Workers KV: Cloudflare's global key-value store cached at the edge, eventually consistent with a stated propagation delay, billed by reads, writes and GB-month (Serverless & Edge Databases).
- Xata: a managed Postgres platform built on copy-on-write branching, with anonymized production clones, branches that hibernate when idle, and a provisioning API for platforms (Serverless & Edge Databases).