AI-200 cheat sheet — every exam topic on one page

Develop containerized solutions on Azure

AI-200 Container Hosting: Azure Container Registry, ACR Tasks and App Service Containers

• Geo-replication, private endpoints, IP/VNet rules, the retention policy and dedicated data endpoints are Premium-only; artifact cache rules and tokens work in every tier.
• Deploy unique tags or digests; stable tags move with every push. write-enabled false makes a tag immutable and undeletable, delete-enabled false only blocks deletion, and az lock never protects images.
• az acr import is a server-side copy that keeps the digest; a cache rule (with a credential set for Docker Hub) is a pull-through cache.
• AcrPull pulls, AcrPush pushes and pulls, AcrDelete deletes. In rbac-abac mode those roles aren't honored; use Container Registry Repository roles with an ABAC condition to scope them.
• az acr build builds without local Docker (--platform, --no-push); az acr run --cmd ... /dev/null runs an image once; $Registry is the login server, $RegistryName the short name.
• Timer cron has five fields in UTC. Base image triggers need one prior run, a stable tag and the runtime stage; ACR bases trigger immediately, public ones within 10 to 60 minutes.
• In task YAML, when lists every prerequisite step and ["-"] runs in parallel; secrets come from a secrets block read by the task's own managed identity.
• App Service pulls with AcrPull plus acrUseManagedIdentityCreds; acrUserManagedIdentityID takes a client ID, keyVaultReferenceIdentity takes a resource ID, and vnetImagePullEnabled routes pulls through the VNet.
• App settings become environment variables; connection strings get type prefixes; slot settings stay with their slot; Key Vault references cache for 24 hours unless refreshed.

AI-200 Container Apps and AKS: Revisions, KEDA Scaling, Manifests and Troubleshooting

• Apps in one Container Apps environment share the VNet, the log destination and Dapr; isolate test and production in separate environments. A custom VNet and internal accessibility are set only when the environment is created.
• Internal ingress means callable only from the same environment; in an internal environment, external ingress means callable from the VNet and peered networks but never the internet. Disable ingress for queue workers.
• Changes under properties.template (image, scale rules) create a revision; changes under properties.configuration (secrets, ingress, traffic, revision mode, registries) don't. Restart the revision after updating a secret, or use a versionless Key Vault URI.
• Weighted traffic needs multiple revision mode; rollback is a weight change; assign weights by revision name to stop new revisions taking traffic; labels give a stable URL that moves between revisions.
• KEDA computes ceil(metric / target) clamped to min and max replicas. With no rule the default HTTP rule applies, so a worker with ingress disabled never wakes up; minReplicas 1 removes cold starts but keeps billing.
• Scale-rule credentials: --scale-rule-identity for managed identity (Service Bus, Event Hubs, Queue Storage), or auth entries mapping triggerParameter to a Container Apps secretRef.
• A Deployment's selector must match its template labels; memory limits cause OOMKilled; env-var ConfigMaps never update in running pods, whole-volume mounts do, subPath mounts don't.
• Empty Service endpoints mean a selector mismatch; connection refused with endpoints means a wrong targetPort; an internal load balancer needs type LoadBalancer plus the azure-load-balancer-internal annotation.
• Startup probes protect slow starts, readiness gates traffic (put dependencies here), liveness restarts hung processes; rollout status gates pipelines, rollout undo rolls back.
• Pending: describe and events. CrashLoopBackOff: logs --previous. AKS tables: ContainerLogV2, KubeEvents, KubePodInventory. Container Apps: system vs console logs, ContainerAppHTTPLogs ResponseFlags UH, az containerapp exec for DNS.

Develop AI solutions by using Azure data management services

AI-200 Azure Cosmos DB for NoSQL: SDK Queries, RUs, Vector Search and Change Feed

• Keyless access = DefaultAzureCredential + a Cosmos DB data-plane role (Built-in Data Reader or Data Contributor); Azure RBAC roles like Contributor manage the account but don't authorise item reads or writes.
• A point read with id and partition key is the cheapest lookup (about 1 RU per 1 KB); queries should be parameterized and scoped with partition_key.
• populate_index_metrics=True returns x-ms-cosmos-index-utilization with used and recommended indexes; x-ms-request-charge only gives the cost.
• Include only queried paths and exclude /* to cut write RU, and always exclude vector paths from range indexing.
• Composite indexes must follow the ORDER BY path order, with directions matching exactly or fully reversed.
• Strong and Bounded Staleness read two replicas (about 2× read RU); Session gives read-your-writes from one replica, and clients can only relax the account default.
• Session consistency travels with the session token: forward it to another process to give that process read-your-writes.
• Vector settings (path, dataType, dimensions, distanceFunction) live in the vector embedding policy; existing entries can't be edited in place, so migrate models via a new path and full re-embed.
• flat ≤ 505 dimensions and exact; quantizedFlat ≤ 4,096 for about 50,000 or fewer vectors in scope; diskANN approximate for larger searches. Use TOP N and filter inside the query.
• Change feed delivery is at-least-once, ordered per partition key, latest version only and without deletes: build idempotent handlers and soft-delete with ttl.

AI-200 Azure Database for PostgreSQL: Entra Connections, Schema Design, Data Types and Connection Pooling

• Entra sign-in: token for https://ossrdbms-aad.database.windows.net/.default as the password, user name = the identity's name, role created with pgaadauth_create_principal in the postgres database.
• Tokens are checked only at sign-in, so pools must fetch a fresh token for every new connection (callable kwargs in psycopg_pool 3.3+).
• psycopg 3: %s or %(name)s placeholders with separate parameters, Jsonb(...) for dicts, cursor.copy() for bulk loads.
• jsonb to filter and index flexible metadata; json only to keep the exact original text; timestamptz for instants; numeric(p,s) for exact amounts; GENERATED ALWAYS AS IDENTITY for database-only keys.
• PostgreSQL does not index foreign key columns; index the child column you join or cascade on.
• Retention by age: range-partition on the time column and drop old partitions; the primary key must include the partition key.
• B-tree: equality columns first, then the range/sort column; expression indexes for functions, partial indexes for small fixed subsets.
• GIN jsonb_path_ops for containment only (smaller); default jsonb_ops when key-exists operators are needed too; pg_trgm GIN for '%term%' after allow-listing it in azure.extensions.
• One small pool per process plus built-in PgBouncer on port 6432 (General Purpose or Memory Optimized only); in transaction mode use SET LOCAL and max_prepared_statements.
• Read replicas are asynchronous and readable; the HA standby is not. Route read-your-own-writes to the primary.

AI-200 Azure Database for PostgreSQL pgvector: HNSW, IVFFlat and DiskANN Indexes, Compute Sizing and RAG Vector Search

• HNSW: best speed-recall, slower and heavier build, no training (fine on an empty table). IVFFlat: fast, light build, trained on existing rows; DiskANN (pg_diskann) for billion-scale search on flexible server.
• IVFFlat lists = rows/1000 up to 1M rows, sqrt(rows) beyond; rebuild after large growth. ANALYZE does not retrain centroids.
• Operators and classes must match: <-> vector_l2_ops, <#> vector_ip_ops (negative inner product), <=> vector_cosine_ops.
• Index scans serve ORDER BY <raw operator> ascending with LIMIT; compute similarity scores in the select list, never sort by them.
• Recall without a rebuild: hnsw.ef_search (default 40) or ivfflat.probes (default 1); use SET LOCAL on pooled connections.
• Faster builds: raise maintenance_work_mem (watch the "no longer fits" notice) and max_parallel_maintenance_workers; load data first.
• Declare vector(n) to index; over 2,000 dimensions index embedding::halfvec(n) and repeat the same cast in the query.
• Burstable is not for production; Memory Optimized when the index must sit in RAM; Premium SSD v2 sets IOPS apart from size, but the compute size caps IOPS too.
• azure_openai.create_embeddings(deployment, text) returns real[]; cast it ::vector.
• RAG retrieval: WHERE filters with AND, ORDER BY embedding <=> query LIMIT k; fix short results with iterative scans, partial indexes or partitions, and match partial-index predicates exactly.

AI-200 Azure Managed Redis: Caching, Expiration, Invalidation and Vector Search

• Modules, including RediSearch for vector search, are chosen only when an instance is created; RediSearch needs the Enterprise or Non-clustered policy and isn't available on Flash Optimized.
• Cache-aside: read Redis, on a miss load from the database and SET with a TTL in the same call. Writers stay unchanged; write-through needs every writer to change.
• Invalidate by deleting the key after the database write commits; deleting first lets a concurrent reader re-cache the old value. Use UNLINK for very large keys.
• SET without KEEPTTL, GETSET and DEL clear a TTL; HSET, INCR and LPUSH keep it. TTL returns -1 for no expiry and -2 for a missing key.
• The default eviction policy is volatile-lru: only keys with a TTL can be evicted, so a TTL doubles as an eviction marker. AllKeysLRU makes every key a candidate.
• With the OSS clustering policy, multi-key commands and transactions need one hash slot; a shared {hash tag} keeps related keys together.
• Spread expirations with TTL jitter and let one caller rebuild a missing key with a SET NX EX lock.
• Hash vectors are raw bytes of DIM × TYPE (np.float32 then tobytes()); JSON vectors are arrays of DIM numbers. Mismatches show as indexing failures.
• FLAT is exact, HNSW approximate; raise EF_RUNTIME per query for more recall without a rebuild. FT.SEARCH returns 10 results unless LIMIT says otherwise, and lower distance means more similar.
• Semantic caches match on prompt meaning only: start with a strict distance_threshold, filter by tenant and version the cache by model and prompt template.

Connect to and consume Azure services

AI-200 Service Bus and Event Grid: Messaging and Event-Driven AI Solutions

• Service Bus stores work until a consumer settles it (days if needed); Event Grid pushes notifications and stops retrying after at most 24 hours. A Service Bus queue can be an Event Grid handler to get both.
• A queue gives each message to one receiver; a topic gives every subscription its own copy. Instances of one service share a queue or subscription; different services get their own subscriptions.
• Basic tier has queues only; topics, sessions and duplicate detection need Standard or Premium, and sessions and duplicate detection must be enabled when the entity is created.
• Use peek-lock and complete after the result is stored; abandon retries now, defer parks a received message, and AutoLockRenewer covers work longer than the lock duration (5 minutes at most).
• Messages reach the dead-letter subqueue after the maximum delivery count (default 10) or on expiry only when dead-lettering on expiration is on; read them with sub_queue=ServiceBusSubQueue.DEAD_LETTER and resubmit them yourself.
• Duplicate detection compares only message_id within the history window; subscription rules are ORed, and the $Default true filter must go before a narrower filter has any effect.
• Keyless access is ServiceBusClient(fully qualified namespace, DefaultAzureCredential()) plus a data role (Data Sender, Data Receiver) at the narrowest scope; Contributor gives no data access.
• A custom topic's input schema is fixed at creation and the delivery schema is per subscription; CloudEvents delivery to a webhook uses the OPTIONS / WebHook-Allowed-Origin handshake.
• Event Grid filters: values within one filter OR, separate filters AND, negated operators such as StringNotIn match a missing key (add IsNotNull); success is 200-204 within 30 seconds; delivery is at least once and unordered.
• Retries end at max attempts (1-30) or event TTL (1-1,440 minutes), whichever comes first; dead-letter only to a Blob container, off by default. Namespace topics pull CloudEvents and settle with acknowledge, release, reject or renew_locks.

AI-200 Azure Functions: Triggers, Bindings, Configuration and Deployment

• Python v2 apps have one func.FunctionApp in function_app.py; split code with func.Blueprint and app.register_functions. A failed top-level import leaves the app with no functions.
• Routes are relative to routePrefix (api by default, set in host.json); read path values from req.route_params; with an empty prefix, routes whose first segment is admin or runtime collide with the host's reserved paths.
• FUNCTION level accepts a function key or any host key; ADMIN needs the master key; system keys are for extension webhooks. Keys aren't enforced locally. Use App Service Authentication for user sign-in and platform CORS for browsers.
• Output bindings write after the function returns, so their errors can't be caught; use a module-scope SDK client when you must handle failures.
• Timer schedules are six-field NCRONTAB in UTC; Flex Consumption doesn't support WEBSITE_TIME_ZONE or TZ. One instance runs each occurrence, but every slot runs its own.
• Storage queue messages move to <queue>-poison after maxDequeueCount (default 5) attempts; concurrency per instance is batchSize + newBatchThreshold.
• Retry policies cover only Timer, Cosmos DB, Event Hubs and Kafka; Service Bus uses its max delivery count and dead-letter queue.
• Identity connections use <prefix>__fullyQualifiedNamespace, __serviceUri (or __blobServiceUri + __queueServiceUri for blob triggers), __accountEndpoint, or AzureWebJobsStorage__accountName, with data-plane roles.
• Flex Consumption: per-function scale groups, always ready per group outside the maximum instance count, Event Grid-only blob triggers, blob-container packages and no deployment slots.
• HTTP responses must return within 230 seconds on every plan whatever functionTimeout says; use the Durable async HTTP API or a queue for long work. Mark environment-specific settings as slot settings.

Secure, monitor, and troubleshoot Azure solutions

AI-200 Azure Key Vault and App Configuration: Secret Retrieval, Rotation and Dynamic Settings

• get_secret(name) returns the latest version; pass version= only to pin. Property listings never include values.
• On an RBAC vault, Secrets User reads, Secrets Officer writes and rotates, Crypto Officer manages keys; Key Vault Contributor has no data access and access policies are ignored.
• set_secret always creates a new version; update_secret_properties changes tags, enabled and dates without one. Disabled versions are blocked, expired ones are still readable.
• Secrets rotate through code: SecretNearExpiry (30 days before exp, which must be set) triggers a function holding Secrets Officer that changes the source first, then the vault.
• Two-credential rotation regenerates the key the latest version doesn't hold, tracked with a CredentialId tag; regenerating a key revokes SAS tokens it signed.
• Keys rotate natively with a rotation policy (minimum 7 days); imported keys use a Notify action, which needs timeBeforeExpiry, a policy expiryTime and a key expiration date.
• Soft delete reserves the name for 7 to 90 days fixed at vault creation; recover to reuse it, purge to free it, and purge protection can never be turned off.
• App Configuration's load() reads unlabelled keys by default; later selectors win; refresh happens only when the app calls refresh(), and the sentinel is updated last.
• Key Vault references are resolved by the app's own identity via keyvault_credential; secret_refresh_interval picks up rotated secrets.
• Snapshots are immutable (only Key composition loads); feature flags need feature_flag_enabled, their own selectors and their own refresh switch.

AI-200 OpenTelemetry Tracing and KQL: Monitor and Troubleshoot Azure Solutions

• use_microsoft_opentelemetry(enable_azure_monitor=True) plus the APPLICATIONINSIGHTS_CONNECTION_STRING environment variable is the production setup; never initialize two distros or re-instrument a bundled library.
• With local authentication disabled, telemetry needs azure_monitor_exporter_credential and the Monitoring Metrics Publisher role on the Application Insights resource itself.
• Cloud role name = service.namespace + '.' + service.name; OTEL_SERVICE_NAME overrides service.name in OTEL_RESOURCE_ATTRIBUTES, and service.instance.id is the role instance.
• SERVER and CONSUMER spans become requests; CLIENT, PRODUCER and INTERNAL (the default, InProc) become dependencies.
• start_as_current_span makes the span current and ends it on exit; span processors enrich every span in on_start, because on_end gets a read-only span.
• OperationId is the trace ID, ParentId is the direct parent's span ID; use inject/extract when no instrumentation carries traceparent.
• Escaping exceptions are recorded and set ERROR automatically; handled ones need record_exception plus set_status, and manual recording before a re-raise duplicates unless record_exception=False.
• The Python default sampler is rate-limited (traces per second); fixed_percentage takes a 0–1 ratio; metrics are never sampled and log sampling by trace is opt-in.
• Filter HTTP paths with OTEL_PYTHON_EXCLUDED_URLS, other spans with a TraceFlags.DEFAULT processor, and rows at ingestion with a workspace transformation DCR.
• In KQL, count sampled data with sum(ItemCount), remember join defaults to innerunique, and query platform metrics in AzureMetrics only after a diagnostic setting exports them.