Store and manage containers in Azure Container Registry
- Explain how Azure Container Registry organizes images using registries, repositories, and artifacts.
- Create and manage container images in the cloud using ACR Tasks
- Implement tagging and versioning policies for reliable container deployments
- Use the Azure CLI to manage container images and run fast ACR tasks
Deploy containers on Azure App Service
- Deploy custom containers to Azure App Service from container registries.
- Configure container runtime behavior, including startup commands, port settings, and persistent storage.
- Configure app settings and connection strings in App Service.
- Observe and troubleshoot issues with containerized applications using App Service diagnostic tools.
Deploy containers to Azure Container Apps
- Explain how Azure Container Apps environments affect networking, logging, and isolation.
- Deploy a container application using Azure CLI and Azure CLI with a YAML definition.
- Configure runtime settings using environment variables and secrets.
- Configure image extraction authentication for private registries.
- Analyze the health of the container application using logs, revisions, and replica status.
Manage containers in Azure Container Apps
- Update container images and manage revisions securely during development and release cycles.
- Perform application lifecycle operations and diagnose failed revisions.
- Monitor logbooks and troubleshoot frequent review and execution issues.
- Configure health probes and troubleshoot probe failures.
- Optimize container resources and scaling settings to balance cost and performance.
Scale containers in Azure Container Apps
- Configure HTTP, TCP, CPU, and memory scale rules for container applications
- Implement event-driven scaling using KEDA scalers for Azure services
- Select the appropriate compute resources to optimize performance and costs
- Apply review modes to control scaling behavior and traffic distribution
Deploy applications on Azure Kubernetes Service
- Create Kubernetes deployment manifests
- Deploy and expose applications on Azure Kubernetes Service
Configurer des applications sur Azure Kubernetes Service
- Explain how to outsource application configuration using Kubernetes primitives.
- Implement ConfigMaps and inject parameters into pods.
- Implement secrets and consume sensitive values securely.
- Attach persistent storage by using PersistentVolume and persistentVolumeClaim.
Monitor and troubleshoot applications on Azure Kubernetes Service
- Explain key monitoring signals for AI workloads running on Azure Kubernetes Service.
- Use kubectl and Azure tools to review application logs and metrics.
- Troubleshoot incidents affecting pods and services that impact APIs and AI workers.
- Check service and ingress connectivity paths to ensure that clients can access AI services.
Build queries for Azure Cosmos DB for NoSQL
- Explain the Azure Cosmos DB resource model for NoSQL and how databases, containers, and items relate to each other.
- Implement SDK operations to connect to Azure Cosmos DB and perform CRUD operations on items
- Select between point reads and queries based on performance requirements and access patterns
- Create queries using SQL syntax to filter, project, and retrieve data from containers
Implement vector search on Azure Cosmos DB for NoSQL
- Store and retrieve vector embeddings in Azure Cosmos DB containers with properly configured vector policies
- Run vector similarity queries using the VectorDistance function to semantically search for similar documents
- Combine vector search with metadata filters and full-text search using hybrid queries
- Implement change feed processing to automatically refresh embeddings when source documents change
Optimize query performance for Azure Cosmos DB for NoSQL
- Analyze query patterns and use metrics to identify performance bottlenecks and missing indexes
- Configure range and composite indexes to optimize filtering and sorting operations for AI recovery models
- Select the appropriate vector index type based on dataset size, precision requirements, and performance goals
- Design indexing strategies that balance read performance versus write costs for your workload profile
- Choose consistency levels that meet application requirements while reducing RU consumption
Build and query with Azure Database for PostgreSQL
- Explain the architecture and key features of Azure Database for PostgreSQL
- Establish secure connections to PostgreSQL using Microsoft Entra and tls authentication
- Create and manage database schemas, including tables, indexes, and constraints
- Write efficient SQL queries for common data operations
- Integrate Azure Database for PostgreSQL into applications using Python
Implement vector search with Azure Database for PostgreSQL
- Store and query vector embeddings using the pgvector extension in Azure Database for PostgreSQL
- Run vector similarity searches using different metrics and distance operators
- Create and manage vector indexes to optimize search performance
- Implement embedded update and refresh policies for dataset evolution
- Create recovery models that integrate PostgreSQL vector search with RAG pipelines
Optimize vector search in Azure Database for PostgreSQL
- Tune PostgreSQL and pgvector configuration settings to optimize query latency and memory usage for AI workloads
- Select and configure the appropriate vector index type based on dataset size, query patterns, and precision requirements
- Design data layouts that optimize metadata filtering and vector storage performance
- Scale Azure Database for PostgreSQL to handle large-scale vector workloads
- Implement connection pooling and session management policies for AI applications
Implement data operations in Azure Managed Redis
- Explain Azure Managed Redis features and caching strategies for high-performance applications.
- Select the appropriate client libraries and apply development best practices for Redis implementations
- Implement data operations, including storage, retrieval, expiration, and cache invalidation models
Implement event messaging with Azure Managed Redis
- Explain Redis publish/subscribe messaging to stream events to multiple AI services simultaneously
- Implement Redis feeds for reliable task queues with automatic retry and failure recovery
- Choose between pub/sub and stream depending on whether you need a coordinated broadcast or working distribution
- Build Python applications that use pub/sub for notifications and flows for pipeline processing
Implement vector storage in Azure Managed Redis
- Create vector indexes and query embeddings for similarity search using Redis as a vector database
- Choose appropriate vector types, distance metrics, and indexing algorithms based on dataset size and accuracy requirements
- Select optimal Redis data structures (hash and JSON) to store vectors with metadata
- Build Python applications that index and query high-dimensional embeddings with Azure Managed Redis
Queue and process AI operations with Azure Service Bus
- Explain how Azure Service Bus decouples AI application components and identify when to apply messaging patterns such as load leveling, concurrent consumers, and publish/subscribe.
- Choose between queues and Service Bus topics with subscriptions depending on whether an AI workflow requires processing for a single consumer or a split for multiple consumers.
- Structure Service Bus messages for AI workloads, including serializing prompts and model parameters, managing large payloads with the claim-verify model, and correlation IDs for end-to-end request tracking.
- Process messages reliably using peek-lock receive mode, handle poison messages through dead-letter queues, and monitor the dead-letter queue for inference failures.
Develop event-driven AI workflows with Azure Event Grid
- Explain how Azure Event Grid enables event-driven models in AI solutions and identifies the core components (topics, event subscriptions, and event handlers) that form an event routing architecture.
- Design events using the CloudEvents schema for AI operations, define custom event types, and configure event subscriptions with filters that route events based on data type, topic, or attributes.
- Configure delivery and retry policies to handle transient failures in AI pipelines, set dead-letter destinations for undeliverable events, and monitor delivery results.
- Publish custom events from AI applications to report completed inferences, model updates, or pipeline stage transitions using the Event Grid SDK and REST API.
Build serverless AI backends with Azure Functions
- Evaluate the trade-offs between cold start, scaling, and instance memory when choosing between Flex Consumption and Premium hosting for AI workloads
- Set up an on-premises development environment for Azure Functions using Core Tools, emulators, and an IDE
- Create triggers and bindings that implement common AI integration patterns such as HTTP inference endpoints and queue-based batch processors
- Configure secrets management and app settings using Key Vault references and Azure App Configuration
- Enforce managed identity and function-level authorization to secure access between Functions and other Azure resources
Manage application secrets with Azure Key Vault
- Explain how Azure Key Vault stores and organizes secrets, keys, and certificates, and identify when to use each type of object in an AI solution.
- Retrieve secrets programmatically using Azure SDK client libraries with managed identity authentication.
- Manage versioning and secret version rotation in the app code to support credential updates without downtime.
- Implement caching strategies that reduce Key Vault API calls while maintaining security and freshness guarantees.
Manage app settings with Azure App Configuration
- Sign in to Azure App Configuration from the app code and retrieve the settings using the Python provider library with managed identity authentication.
- Organize configuration settings with labels and implement feature flags to monitor feature availability without redeploying.
- Reference Azure Key Vault secrets from App Configuration to unify access to configuration and secrets in a single recovery path.
- Determine which settings belong to App Configuration and which belong to Key Vault based on sensitivity, structure, and access patterns.
Instrumenting an application with OpenTelemetry
- Explain how OpenTelemetry provides vendor-neutral observability for distributed AI applications on Azure.
- Add and configure Azure Monitor OpenTelemetry distribution in an application to collect telemetry data.
- Create and manage custom scopes and traces to capture request flows between distributed services.
- Export telemetry to Azure Monitor Application Insights for analysis and visualization.
- Use trace data in Application Insights to identify and debug performance issues in distributed workflows.
Analyze application telemetry with logs and metrics
- Write KQL queries to retrieve and analyze application telemetry data from Application Insights.
- Explore log data to identify error patterns, performance bottlenecks, and trends in application behavior.
- Create Azure dashboards that display key telemetry metrics and log query results for operational monitoring.
- Create Azure Monitor workbooks for interactive analysis of parameter-driven telemetry.
- Configure alert rules that detect application failures, performance degradation, and anomalies.
