Microsoft Azure AI Cloud Developer

Images need a home and a policy. You store images in Azure Container Registry, tag and promote them deliberately, authenticate pulls without shared passwords, and build images in the cloud.

• Creating and securing a container registry
• Tagging, versioning and immutability
• Cloud-side builds with ACR Tasks
• Pulling images with a managed identity
• Image scanning and retention
• Geo-replication for distant regions

You build A registry with a build task that produces tagged images and removes old ones.

The simplest host that meets the need is usually the right one. You deploy containers to App Service and Container Apps, configure scaling, ingress and revisions, and decide which platform fits each workload.

• Web App for Containers on App Service
• Deployment slots and swaps
• Container Apps environments, ingress and revisions
• Autoscaling rules from HTTP load and metrics
• Jobs and background workers
• Choosing between App Service and Container Apps

You build The same AI API hosted on App Service and on Container Apps, with a written comparison.

When a workload outgrows managed hosts, Kubernetes takes over. You deploy to AKS, expose and configure workloads, and scale them from queue depth and other events with KEDA, down to zero when idle.

• AKS clusters, node pools and the control plane
• Deployments, services and ingress
• ConfigMaps, Secrets and workload identity
• Scaling with HPA and KEDA scalers
• Scaling inference workers on queue length
• Troubleshooting pods that will not start

You build An AKS deployment of an AI worker that scales with queue depth.

Cosmos DB holds the state of many AI apps: conversations, documents and agent memory. You model data for it, write efficient queries, and tune throughput and indexing for the access patterns you actually have.

• Data modeling: embed or reference
• Choosing partition keys
• Point reads and queries in the Python SDK
• Indexing policy and request units
• Change feed for downstream processing
• Storing conversation and agent state

You build A Cosmos DB container for chat history, with a partition key and queries measured in request units.

Many teams already run PostgreSQL. You add vectors to it with pgvector, store embeddings next to relational data, build similarity indexes, and tune the balance between recall and speed.

• Embeddings and similarity measures
• Enabling and using the pgvector extension
• Storing embeddings beside relational rows
• HNSW and IVFFlat indexes
• Combining filters with vector search
• Tuning recall against latency

You build A PostgreSQL table of embedded documents with a vector index and measured recall.

Speed often comes from not repeating work. You use Azure Managed Redis as a cache, session store and vector index, and design expiry and invalidation so cached answers stay correct.

• Redis data structures and when each fits
• Caching model responses and expensive lookups
• Semantic caching with vectors
• Expiry, eviction and invalidation
• Session and rate-limit state
• Sizing and resilience of a Redis deployment

You build A cache layer in front of an AI endpoint, with hit rate and cost savings measured.

Cosmos DB, PostgreSQL and Redis can all serve vectors, each with different strengths. You compare them on one dataset and decide using recall, latency, cost and the operations a team can sustain.

• A fair benchmark across three stores
• Dimensions, quantization and index size
• Hybrid keyword and vector queries
• Filtering and multi-tenant isolation
• Cost per query and cost of storage
• Migrating from one store to another

You build A benchmark report that recommends a vector store for one workload, with the numbers behind it.

Reliable AI back ends hand work off rather than wait on it. You use Service Bus queues and topics for commands and Event Grid for notifications, and handle retries, poison messages and ordering.

• Queues, topics and subscriptions in Service Bus
• Sessions, ordering and duplicate detection
• Dead-letter queues and poison messages
• Event Grid topics and subscriptions
• Commands compared with events
• Writing idempotent consumers

You build A pipeline where uploads raise events, work flows through a queue and failures land in a dead-letter queue.

Functions fit short, spiky, event-driven work. You write functions in Python with triggers and bindings, call AI services from them, and choose a hosting plan that handles cold starts and scale.

• Triggers and bindings
• HTTP, queue, timer and blob triggers
• Durable Functions for multi-step work
• Calling AI services from a function
• Hosting plans and cold starts
• Deploying and configuring a function app

You build A function app that processes uploaded documents through an AI service and stores the results.

Credentials in code are an incident waiting to happen. You keep secrets in Key Vault, settings and feature flags in App Configuration, and reach both with managed identities so that no key lives in an image.

• Managed identities for service-to-service access
• Storing and rotating secrets in Key Vault
• Key Vault references in app settings
• Centralized settings in App Configuration
• Feature flags and dynamic refresh
• Role assignments for least privilege

You build A service whose secrets and settings are fetched at runtime, with no credentials in code or images.

A single request may cross a gateway, a queue, a function and a model. You instrument services with OpenTelemetry, follow one request through all of them, and ask questions of the logs with KQL.

• OpenTelemetry traces, metrics and logs
• Instrumenting Python services
• Application Insights and Azure Monitor
• Correlating a request across services
• KQL for latency and error analysis
• Tracking token use and model latency
• Alerts on failures and slow calls

You build A traced request path across three services, with KQL queries and alerts.

Assemble a complete back end. You containerize and host a service, add a data layer with vector search, connect it with messaging and functions, secure it, and trace the whole path from end to end.

• Planning the services and the data
• Hosting and scaling the API
• Adding storage, search and caching
• Connecting events and workers
• Securing and observing the system

You build A deployed back end for an AI application, with hosting, data, messaging, secrets and tracing in place.