AI-200 · Glossary

The terms, in one sentence each

107 terms from the AI-200 study guide. Each one links to the card that explains it.

A

ACR Tasks also: ACR task: A feature of Azure Container Registry that builds, tests and patches container images in Azure, on demand or from triggers. Study card: ACR Tasks →
App Configuration also: Azure App Configuration: An Azure service that centrally stores application settings as key-values and manages feature flags, so apps can change settings without redeploying. Study card: App Configuration →
App Configuration label also: App Configuration labels: An optional attribute that tells apart key-values with the same key, commonly one label per environment such as Test or Production. Study card: App Configuration →
app setting also: app settings: A name and value stored with an App Service app and passed to your code as an environment variable at startup. Study card: App Service containers →
Application Insights: The Azure Monitor feature for application performance monitoring. It receives traces, metrics and logs from your app and stores them in a Log Analytics workspace. Study card: OpenTelemetry tracing →
autovacuum also: vacuum: The PostgreSQL background process that reclaims space held by dead row versions, which build up quickly when embeddings are updated often. Study card: Vector workload sizing →
Azure App Service also: App Service: An Azure platform service that hosts web apps and APIs, from code or from a container image, without you managing servers. Study card: App Service containers →
Azure Container Apps also: Container Apps: A serverless Azure service that runs containers and microservices with built-in ingress, revisions and scaling, without managing a cluster. Study card: Container Apps revisions →
Azure Container Registry also: ACR: A managed registry service in Azure that stores and distributes private container images and related artifacts. Study card: ACR images and tags →
Azure Kubernetes Service also: AKS: The Azure managed Kubernetes service, where Azure runs the control plane and you run your containerized apps on node pools. Study card: AKS manifests →
azure_ai extension also: azure_ai: A PostgreSQL extension on Azure that calls Azure AI services from SQL, for example to create embeddings or rerank results. Study card: PostgreSQL RAG search →

B

base image also: base images: The parent image named in the FROM line of a Dockerfile, usually holding the operating system and a framework. Study card: ACR Tasks →
binding also: bindings, input binding, output binding, output bindings: A declarative link from a function to another service. An input binding passes data in as a parameter, an output binding sends data out, so no SDK code is needed. Study card: Functions triggers and bindings →
Burstable also: Burstable tier: The compute tier of a flexible server for workloads that stay below full CPU. It runs on CPU credits and is meant for development and test, not for production. Study card: Vector workload sizing →

C

cache invalidation also: invalidation: Removing a cached item because the data behind it changed. In cache-aside, the application deletes the key after it updates the data store. Study card: Redis cache-aside →
cache-aside also: cache-aside pattern: A caching pattern in which the application checks the cache first, loads from the data store on a miss, and then adds the item to the cache itself. Study card: Redis cache-aside →
change feed also: change feeds: A persistent, ordered record of the inserts and updates made to the items of a container. Consumers read it to react to changes without polling with queries. Study card: Cosmos change feed →
change feed processor also: change feed processors: A library for .NET and Java that reads the change feed, shares the work across instances, and saves its progress in a lease container. Study card: Cosmos change feed →
clustering policy also: clustering policies, Enterprise clustering policy, OSS clustering policy: A cache setting, chosen at creation, that decides how clients connect to the sharded cache. Enterprise uses one endpoint, while OSS lets cluster-aware clients reach the shards directly. Study card: Redis vector search →
composite index also: composite indexes: An index over two or more properties in a fixed order and direction. An ORDER BY on several properties needs one, and filters on several properties run cheaper with one. Study card: Cosmos indexing and RUs →
connection pooling also: connection pool, connection pools: Keeping a set of open database connections that requests borrow and return, instead of opening and closing a new connection for every request. Study card: Connection pooling →
consistency level also: consistency levels: How fresh and how ordered the data returned by a read is guaranteed to be. Cosmos DB offers five levels, from strong to eventual. Study card: Cosmos indexing and RUs →
console log also: console logs: In Container Apps, the stdout and stderr output that your own containers write, which you read to debug the application. Study card: Container troubleshooting →
container app replica also: container app replicas: One running instance of a container app revision. Container Apps adds and removes replicas as the revision scales out and in. Study card: Container Apps revisions →
Container Apps environment also: Container Apps environments: The secure boundary around one or more container apps. Apps in the same environment share a virtual network and a log destination. Study card: Container Apps revisions →
container image also: container images: A read-only package of an application and everything it needs to run, which a container host starts as a container. Study card: ACR images and tags →
continuation token also: continuation tokens: A string that marks how far a reader has got, for example in the change feed pull model. Saving it lets the reader resume from that point later. Study card: Cosmos change feed →
CosmosClient: The main class of the azure-cosmos Python package. You build it from the account endpoint and a credential, then get database and container clients from it. Study card: Cosmos SDK queries →
cross-partition query also: cross-partition queries: A query with no equality filter on the partition key, so Cosmos DB runs it against every physical partition and merges the results. Study card: Cosmos SDK queries →
custom container also: custom containers: Your own container image that App Service runs, as opposed to one of its built-in runtime images. Study card: App Service containers →
custom topic also: custom topics: An Event Grid topic that your own application publishes events to. It has its own endpoint and access keys, and you choose its event schema when you create it. Study card: Event Grid routing →

D

dead-letter queue also: dead-letter queues, DLQ, DLQs: A secondary sub-queue of a Service Bus queue or subscription that holds messages that could not be delivered or processed, so you can inspect them later. Study card: Service Bus messaging →
DefaultAzureCredential: A Python azure-identity credential that tries several sign-in sources in order, such as environment variables, a managed identity and the Azure CLI, and uses the first that works. Study card: Key Vault rotation →
DiskANN: An approximate nearest neighbor index developed by Microsoft Research. It gives up a little recall to get low latency and low RU cost on large sets of vectors. Study card: Cosmos vector search →
distance function also: distance functions: The formula that scores how close two vectors are. Cosine compares their angle, dot product multiplies matching numbers, and Euclidean measures straight-line distance. Study card: Cosmos vector search →
distance threshold also: distance thresholds: A cutoff on the distance value in a WHERE clause that drops matches which are not close enough to count as relevant. Study card: PostgreSQL RAG search →

E

embedding also: embeddings: A list of numbers produced by an embedding model that represents the meaning of a text or an image. Items with similar meaning get vectors that sit close together. Study card: Cosmos vector search →
event filter also: event filters: A rule on an event subscription that selects events by event type, by the start or end of the subject, or by values in the event data. Study card: Event Grid routing →
Event Grid also: Azure Event Grid: Azure's managed event routing service. Publishers send events to a topic, and Event Grid pushes each event to every subscriber whose subscription matches it. Study card: Event Grid routing →
event subscription also: event subscriptions: The Event Grid resource that tells Event Grid which events of a topic to deliver and where, such as a webhook or an Azure Function. It carries the filters and retry settings. Study card: Event Grid routing →
eviction policy also: eviction policies: The rule Redis follows to remove keys when memory is full. The default, volatile-lru, removes the least recently used keys among those that have a time to live. Study card: Redis cache-aside →
extension bundle also: extension bundles: A versioned set of binding extensions that a non-.NET function app loads through host.json, so that triggers and bindings beyond HTTP and timer work. Study card: Functions hosting and deploy →

F

feature flag also: feature flags: A named switch stored in App Configuration that turns a feature on or off, or rolls it out to a share of users, without deploying new code. Study card: App Configuration →
flexible server also: flexible servers: The deployment option of Azure Database for PostgreSQL where Azure runs a managed PostgreSQL server for you, with settings for compute, storage and networking. Study card: PostgreSQL from Python →
foreign key also: foreign keys: A column whose value must match a key in another table. It links rows, such as chunks, to the source document they came from. Study card: Vector schema design →
function app also: function apps: The Azure resource that hosts one or more functions. Its functions deploy together, run on one hosting plan and share the same app settings. Study card: Functions hosting and deploy →
function trigger also: function triggers, Functions trigger, Functions triggers: The event that starts one run of an Azure Function, such as an HTTP request, a timer tick or a queue message. Every function has exactly one trigger. Study card: Functions triggers and bindings →

H

halfvec: A pgvector column type that stores each number in 16 bits instead of 32, which halves the storage of a vector column at some cost in precision. Study card: Vector schema design →
HNSW also: Hierarchical Navigable Small Worlds, Hierarchical Navigable Small World: Hierarchical Navigable Small Worlds, a pgvector index that searches a layered graph of neighbors. It is fast and accurate but slower to build and heavier on memory. Study card: pgvector index tuning →
host.json: A file at the root of a function app that configures all of its functions, such as the extension bundle, the function timeout and logging. Study card: Functions hosting and deploy →
hosting plan also: hosting plans, hosting option: The plan a function app runs on, such as Flex Consumption, Premium, Dedicated or Container Apps. It decides how the app scales, what it can reach and how it is billed. Study card: Functions hosting and deploy →

I

image tag also: image tags: The label after the colon in an image name, such as 1.0 or b4821, that names one version of an image in a repository. Study card: ACR images and tags →
indexing policy also: indexing policies: A per-container setting that says which item property paths are indexed, which index types apply, and whether indexing is on. The default indexes every property. Study card: Cosmos indexing and RUs →
IVFFlat also: Inverted File with Flat Compression: Inverted File with Flat Compression, a pgvector index that groups vectors into lists and searches only the closest lists, set by the probes option. Study card: pgvector index tuning →

K

KEDA also: Kubernetes Event-driven Autoscaling: Kubernetes Event-driven Autoscaling, the open-source component that Container Apps uses to scale replicas from events and metrics. Study card: KEDA scaling →
KEDA scaler also: scaler, scalers, KEDA scalers: A KEDA component that reads one event source, such as an Azure queue, and reports the metric a scale rule acts on. Study card: KEDA scaling →
Key Vault also: Azure Key Vault: An Azure service that stores secrets, keys and certificates and controls who can read them. Applications fetch secrets from it instead of keeping them in code or settings. Study card: Key Vault rotation →
Key Vault reference also: Key Vault references: An app setting value of the form @Microsoft.KeyVault(SecretUri=...) that makes App Service or Azure Functions read the setting from a Key Vault secret, with no code change. Study card: Key Vault rotation →
KNN query also: KNN, KNN queries: A RediSearch query that returns the K stored vectors nearest to a query vector, optionally filtered by metadata fields. Study card: Redis vector search →
KQL also: Kusto Query Language: Kusto Query Language, the read-only query language of Azure Monitor Logs and Azure Data Explorer. A query is a pipeline of operators applied to a table. Study card: KQL for logs →
kubectl: The command-line tool for talking to a Kubernetes cluster, used to apply manifests, list objects, read logs and describe problems. Study card: Container troubleshooting →
Kubernetes Deployment: A Kubernetes object that keeps a set number of identical pods running from a pod template and replaces them during updates. Study card: AKS manifests →
Kubernetes event also: Kubernetes events: A short record that Kubernetes writes when something happens to an object, such as a pod being scheduled, pulled or restarted. Study card: Container troubleshooting →
Kubernetes Service also: Kubernetes Services: A Kubernetes object that gives a group of pods one stable IP address and DNS name, and routes traffic to the pods its selector matches. Study card: AKS manifests →

L

lease container also: lease containers: A container that stores one lease document per range of partition key values. A lease records how far that range has been processed and which instance owns it. Study card: Cosmos change feed →
local.settings.json: A file used only when you run a function app locally. Its Values collection holds the app settings that your code reads as environment variables. Study card: Functions hosting and deploy →
Log Analytics workspace also: Log Analytics workspaces: The Azure Monitor data store that holds log tables, including the Application Insights tables of a workspace-based resource. You run KQL queries against it. Study card: KQL for logs →

M

maintenance_work_mem: The PostgreSQL setting for the memory that maintenance work such as CREATE INDEX and VACUUM may use. It is separate from work_mem, which serves queries. Study card: Vector workload sizing →
managed identity also: managed identities: An identity in Microsoft Entra ID that Azure creates for a resource, such as a function app, so it can get tokens and call other services without any stored password. Study card: Key Vault rotation →
manifest digest also: digest, digests: The SHA-256 hash that the registry generates for an image manifest. It identifies one exact image, whatever tags point to it. Study card: ACR images and tags →
manifest file also: manifest files, Kubernetes manifest, Kubernetes manifests: A YAML file that declares Kubernetes objects, such as Deployments and Services, and the state you want the cluster to reach. Study card: AKS manifests →
metadata filter also: metadata filters: A condition on ordinary columns, such as category or date, that limits which rows a vector query may return. Study card: PostgreSQL RAG search →
multi-step task also: multi-step tasks: An ACR task defined in a YAML file as steps that build images, run containers and push results, optionally in parallel. Study card: ACR Tasks →

O

OpenTelemetry also: OTel: An open, vendor-neutral standard and set of libraries for collecting traces, metrics and logs from applications. Azure Monitor accepts this data through its distro. Study card: OpenTelemetry tracing →
operator class also: operator classes: The part of a PostgreSQL index definition that says which operator the index supports, for example vector_cosine_ops for the cosine distance operator. Study card: pgvector index tuning →

P

parameterized query also: parameterized queries: A SQL statement that holds placeholders such as %s, with the values passed separately instead of being pasted into the SQL text. Study card: PostgreSQL from Python →
partial index also: partial indexes: An index built only on the rows that match a WHERE condition. It is smaller and faster, but only queries with a matching condition can use it. Study card: pgvector index tuning →
partition key also: partition keys: The item property whose value decides which logical partition an item belongs to. A query with an equality filter on it can stay inside one partition. Study card: Cosmos SDK queries →
peek-lock also: peek lock, peek-lock mode: A receive mode in which Service Bus locks a message while your code works on it. The message is removed only when you complete it, otherwise it is delivered again. Study card: Service Bus messaging →
PgBouncer: A lightweight connection pooler for PostgreSQL. Azure offers it built in to flexible servers, and you can also run your own copy on a VM or in a container. Study card: Connection pooling →
pod also: pods: The smallest unit Kubernetes runs, one or more containers that share network and storage and are scheduled together on a node. Study card: AKS manifests →
point read also: point reads: Fetching one item by its id and partition key value, with read_item in Python. It is the cheapest and fastest way to read. Study card: Cosmos SDK queries →
Premium SSD v2: A storage type for flexible servers where you set capacity, IOPS and throughput separately and can adjust them as the workload changes. Study card: Vector workload sizing →
psycopg: The most widely used Python driver for PostgreSQL. It opens connections, runs SQL through cursors and follows the Python database API. Study card: PostgreSQL from Python →

Q

quick task also: quick tasks: A single on-demand build and push in Azure, started with az acr build, that needs no local Docker engine. Study card: ACR Tasks →

R

RAG also: retrieval-augmented generation, Retrieval Augmented Generation: Retrieval-augmented generation, a pattern where the app first retrieves relevant data from your own store and gives it to a language model as context for its answer. Study card: PostgreSQL RAG search →
readiness probe also: readiness probes: A health check that decides whether a pod or replica is ready for traffic. A failing pod is left out of the Service endpoints. Study card: Container troubleshooting →
RediSearch: A Redis module that adds a search engine and secondary indexes to Redis, including vector similarity search. In Azure Managed Redis you enable it when you create the cache. Study card: Redis vector search →
Request Unit also: Request Units, RU, RUs: The currency Cosmos DB uses to price every operation, based on the CPU, memory and IO it needs. Throughput is provisioned and measured in Request Units per second. Study card: Cosmos indexing and RUs →
revision also: revisions: An immutable snapshot of one version of a container app, created when you deploy or change its template. Study card: Container Apps revisions →

S

scale rule also: scale rules, scaling rule, scaling rules: The criterion that tells Container Apps when to add or remove replicas, such as concurrent HTTP requests or queue length. Study card: KEDA scaling →
scale to zero also: scales to zero, scaled to zero, scale-to-zero: Running no replicas while there is no work. The app starts a replica again when a scale rule fires. Study card: KEDA scaling →
sentinel key also: sentinel keys: A key you change last, after updating other settings. The app watches only this key and reloads all its settings when it changes. Study card: App Configuration →
Service Bus queue also: Service Bus queues: A Service Bus entity that stores messages in order until a receiver takes them. Each message is delivered to one receiver, so workers can share the load. Study card: Service Bus messaging →
Service Bus subscription also: Service Bus subscriptions, topic subscription, topic subscriptions: A named, queue-like view of a topic. It receives a copy of every message that passes its filter rules, and receivers read from it like from a queue. Study card: Service Bus messaging →
Service Bus topic also: Service Bus topics: A Service Bus entity that senders publish to. It does not hold messages for receivers itself, it copies each message to its subscriptions. Study card: Service Bus messaging →
span also: spans: One timed step inside a trace, such as handling a request or calling a database. It has a name, start and end time, attributes and a parent span. Study card: OpenTelemetry tracing →
system log also: system logs: In Container Apps, the messages the platform writes about your app, such as revision provisioning, scaling and traffic weight changes. Study card: Container troubleshooting →

T

time to live also: TTL: How many seconds a key stays in the cache before Redis removes it automatically. You set it with a command such as EXPIRE. Study card: Redis cache-aside →
trace also: traces, distributed trace, distributed traces: The record of one end-to-end operation, made of a tree of spans that share one identifier, even when the work crosses several services. Study card: OpenTelemetry tracing →
traffic splitting: Sending set percentages of a container app's incoming requests to different active revisions, for example 80 and 20. Study card: Container Apps revisions →
transaction pooling also: transaction pool mode: A PgBouncer mode that lends a server connection to a client only for the length of one transaction, then returns it to the pool for others to use. Study card: Connection pooling →

V

vector data type also: vector type: The pgvector column type that stores an embedding as a fixed-length list of numbers, declared as vector(n) for n dimensions. Study card: Vector schema design →
vector field also: vector fields: A field in a RediSearch index schema that holds an embedding. It is declared with an index type, a vector type, the dimensions and a distance metric. Study card: Redis vector search →
vector indexing policy also: vector indexing policies: A container setting that picks the index type (flat, quantizedFlat or diskANN) for each vector path, so a vector search does not have to scan every vector. Study card: Cosmos vector search →
vector search also: vector similarity search, similarity search: Finding the items whose embeddings are closest to the embedding of a query, instead of matching exact words. It ranks results by similarity in meaning. Study card: Cosmos vector search →

W

WEBSITES_PORT: The app setting that tells App Service which port your custom container listens on, when it is not port 80. Study card: App Service containers →

Study guide Study cards Practice questions