Store and manage containers in Azure Container Registry

Use Azure Container Registry to store, build, and manage container images for AI applications. Learn the registry hierarchy, build images with ACR Tasks, and implement tagging strategies for reliable deployments.

• Registries, repositories, and artifacts
• Build and run images with ACR Tasks
• Tag and version images
• Exercise - Build and manage a container image with ACR Tasks

Deploy containers to Azure App Service

Deploy and manage containerized applications on Azure App Service by configuring container sources, runtime settings, application configuration, and diagnostics.

• Deploy containers to Azure App Service
• Configure container runtime behavior
• Configure application settings
• Observe and troubleshoot containerized apps
• Exercise - Deploy a container to Azure App Service

Deploy containers to Azure Container Apps

Create and manage container deployments in Azure Container Apps. Work with environments, runtime configuration, registry authentication, and deployment verification techniques.

• Explore Container Apps environments
• Deploy a container app using the Azure CLI and YAML
• Configure runtime settings with environment variables and secrets
• Configure image pull authentication for private registries
• Verify deployments with logs and status
• Exercise - Deploy a containerized backend API to Container Apps

Manage containers in Azure Container Apps

Manage container apps across the day-two lifecycle. Update images, manage revisions, diagnose failing deployments, tune resources and scaling, and troubleshoot with logs and health probes.

• Update images and manage revisions safely
• Manage the container app lifecycle
• Monitor logs and troubleshoot issues
• Configure health probes and troubleshoot failures
• Optimize container resources and scaling
• Exercise - Diagnose and fix a failing deployment

Scale containers in Azure Container Apps

Learn how to configure automatic horizontal scaling for containerized applications in Azure Container Apps. Configure HTTP, TCP, CPU, and memory scale rules, implement event-driven scaling with KEDA, optimize compute resources, and apply revision modes for traffic management.

• Configure scale rules
• Implement event-driven scaling with KEDA
• Apply KEDA scalers for custom workloads
• Select compute resources for performance and cost
• Choose and apply revision modes
• Exercise - Configure autoscaling using KEDA triggers

Deploy applications to Azure Kubernetes Service

Learn how to deploy applications to Azure Kubernetes Service. This module covers creating deployment manifests, exposing applications with services, and deploying to Azure Kubernetes Service.

• Create Kubernetes deployment manifests
• Expose applications in Azure Kubernetes Services
• Deploy applications to Azure Kubernetes Services
• Exercise - Deploy an AI inference API to Azure Kubernetes Service

Configure applications on Azure Kubernetes Service

Learn to externalize configuration, secure sensitive settings, and attach persistent storage using Kubernetes features on Azure Kubernetes Service.

• Define ConfigMaps for application settings
• Implement secrets for sensitive data
• Attach persistent storage to an app
• Exercise - Configure apps on Azure Kubernetes Service

Monitor and troubleshoot applications on Azure Kubernetes Service

Learn to monitor application health, inspect logs and metrics, troubleshoot pods and Services, and verify connectivity for AI workloads on Azure Kubernetes Service (AKS).

• Monitor application logs and metrics
• Troubleshoot pods and services
• Verify service connectivity and endpoints
• Exercise - Troubleshoot apps on Azure Kubernetes Service

Build queries for Azure Cosmos DB for NoSQL

Learn how to connect to Azure Cosmos DB for NoSQL using the SDK, perform data operations on items, and write efficient SQL queries to retrieve document data for AI applications.

• Explore Azure Cosmos DB for NoSQL
• Implement the Azure Cosmos DB for NoSQL SDK
• Query Azure Cosmos DB for NoSQL
• Exercise - Build a RAG document store on Azure Cosmos DB for NoSQL

Implement vector search on Azure Cosmos DB for NoSQL

Learn how to store vector embeddings, execute similarity queries using the VectorDistance function, combine vector search with metadata filters and hybrid search, and use the change feed to keep embeddings synchronized.

• Store and retrieve embeddings in Azure Cosmos DB
• Execute vector similarity queries for semantic search
• Combine vector similarity results with metadata filtering
• Use the change feed to trigger embedding refresh
• Exercise - Build a semantic search application with Azure Cosmos DB for NoSQL

Optimize query performance for Azure Cosmos DB for NoSQL

Learn how to optimize query performance by analyzing query patterns, configuring range and composite indexes, selecting vector index types, and choosing consistency levels that balance freshness with cost efficiency.

• Understand indexes in Azure Cosmos DB
• Configure range and composite indexes
• Tune vector indexes for embedding workloads
• Reduce RU costs with strategic indexing
• Choose consistency levels for optimal performance
• Exercise - Optimize query performance with vector indexes on Azure Cosmos DB for NoSQL

Build and query with Azure Database for PostgreSQL

Learn how to use Azure Database for PostgreSQL to build data foundations for AI applications. Design schemas, write efficient queries, and integrate with Python applications using secure authentication.

• Explore Azure Database for PostgreSQL
• Connect to PostgreSQL
• Create and manage schemas
• Query data
• Integrate SDKs and applications
• Exercise - Build an agent tool backend on Azure Database for PostgreSQL

Implement vector search with Azure Database for PostgreSQL

Learn how to implement vector search using the pgvector extension in Azure Database for PostgreSQL. Store embeddings, create vector indexes, and build semantic retrieval patterns for AI applications.

• Store and query embeddings with pgvector
• Perform fast vector similarity search
• Manage index lifecycle and embedding updates
• Run vector similarity search for semantic retrieval
• Implement retrieval patterns for RAG pipelines
• Exercise - Implement vector search on Azure Database for PostgreSQL

Optimize vector search in Azure Database for PostgreSQL

Learn how to optimize vector search performance in Azure Database for PostgreSQL using pgvector. Tune configuration parameters, select and configure vector indexes, design efficient data layouts, scale for high-volume workloads, and implement connection pooling for AI applications.

• Tune PostgreSQL for pgvector
• Choose and configure vector indexes
• Optimize data layout
• Scale for high-volume workloads
• Connection optimization
• Exercise - Optimize vector search performance in Azure Database for PostgreSQL

Implement data operations in Azure Managed Redis

Learn how to implement data operations in Azure Managed Redis. This module covers Azure Managed Redis features, client library best practices, and how to store and retrieve data efficiently.

• Explore Azure Managed Redis
• Client libraries and development best practices
• Implement data operations
• Exercise - Perform data operations in Azure Managed Redis

Implement event messaging with Azure Managed Redis

Learn how to implement event messaging with Azure Managed Redis, including pub/sub for broadcasting notifications and Redis Streams for reliable async task processing. This module covers building real-time notification systems and coordinating multi-step processing pipelines.

• Publish and subscribe to events with Redis pub/sub
• Implement task queues with Redis Streams
• Choose between broadcast and coordinated distribution
• Exercise - Publish and subscribe to events in Azure Managed Redis

Implement vector storage in Azure Managed Redis

Learn how to implement vector storage and similarity search in Azure Managed Redis. This module covers creating vector indexes, querying embeddings, choosing vector types and indexing strategies, and selecting optimal data structures for AI applications.

• Index and query vector data
• Choose vector types and indexing strategies
• Optimize Redis data structures for vector storage
• Exercise - Implement semantic search in Azure Managed Redis

Queue and process AI operations with Azure Service Bus

Learn how to use Azure Service Bus to decouple AI application components, queue inference requests, distribute processing workloads across competing consumers, and handle failures through dead-letter queues. This module covers queues, topics with subscriptions, message structuring for AI payloads, and reliable message processing with the Python SDK.

• Explore Azure Service Bus concepts and messaging in AI architectures
• Choose between queues and topics with subscriptions
• Structure messages for AI workloads
• Process messages reliably
• Exercise - Process messages with Azure Service Bus

Develop event-driven AI workflows with Azure Event Grid

Build reactive AI architectures using Azure Event Grid to route events from sources to handlers with low latency and high reliability. Learn to configure event subscriptions, design CloudEvents, implement delivery policies, and publish custom events from AI applications.

• Understand Azure Event Grid concepts and event-driven patterns for AI solutions
• Work with event schemas and properties
• Configure delivery and retry policies for reliable event processing
• Publish custom events from AI applications
• Exercise - Publish and receive events with Azure Event Grid

Build serverless AI backends with Azure Functions

Learn how to use Azure Functions as lightweight serverless compute for AI workloads. Build inference endpoints, event processors, and service integrations that scale automatically with demand.

• Understand Azure Functions hosting and scaling for AI workloads
• Set up the local development environment for Functions
• Create triggers and bindings for AI integration patterns
• Manage secrets and configuration in Functions
• Configure identity and access for Functions
• Exercise - Create an MCP server with Azure Functions

Manage application secrets with Azure Key Vault

Learn how to use Azure Key Vault to store, retrieve, and manage secrets in AI solutions on Azure. This module covers vault organization, SDK-based secret retrieval with managed identity, secret versioning and rotation strategies, and caching patterns that reduce API calls while maintaining credential freshness.

• Store and organize secrets, keys, and certificates
• Retrieve secrets using Azure SDK client libraries
• Handle secret versioning and rotation
• Implement caching strategies to reduce Key Vault calls
• Exercise - Manage secrets with Azure Key Vault

Manage application settings with Azure App Configuration

Learn how to use Azure App Configuration to centralize application settings for AI solutions on Azure. This module covers connecting from Python application code with managed identity, organizing settings with labels and feature flags, referencing Key Vault secrets, and deciding which settings belong in each service.

• Connect to App Configuration from application code
• Organize settings with labels and feature flags
• Reference Key Vault secrets from App Configuration
• Decide what to store in App Configuration vs Key Vault
• Exercise - Retrieve settings and secrets from Azure App Configuration

Instrument an app with OpenTelemetry

Learn how to instrument distributed applications with OpenTelemetry on Azure, create custom spans and traces, export telemetry to Azure Monitor Application Insights, and use trace data to debug performance issues in distributed AI solutions.

• Explore OpenTelemetry and its role in observability
• Add the OpenTelemetry SDK to an application
• Configure spans and traces
• Export telemetry to Azure Monitor
• Debug distributed flows with trace data
• Exercise - Instrument an app with the OpenTelemetry SDK

Analyze app telemetry with logs and metrics

Learn to write KQL queries against Application Insights logs, explore error patterns and performance trends, build dashboards and workbooks for ongoing visibility, and configure alerts to detect failures and anomalies in AI solutions on Azure.

• Write basic KQL queries
• Explore logs for errors and performance
• Build dashboards for app telemetry
• Create workbooks for interactive analysis
• Set alerts for app failures and anomalies
• Exercise - Query logs with KQL