Free AI-200 Braindumps Download Updated on Jul 22, 2026 with 93 Questions
Microsoft AI-200 Exam Practice Test Questions
NEW QUESTION # 45
Case Study 1 - Fabrikam Inc.
Background
Fabrikam Inc. is a global retail analytics company that provides AI-driven demand forecasting and product recommendation services to online retailers. The company is modernizing its solution to run entirely on Microsoft Azure.
The platform ingests transaction data, generates embeddings for semantic retrieval, performs vector similarity search, and returns product recommendations through containerized microservices. Developers use Python and Azure SDKs. Operations teams manage container orchestration, scaling, monitoring, and security.
The solution must meet strict performance, scalability, and security requirements.
Current environment
Application architecture
The Recommendation engine is a customer-facing HTTP API running as a containerized Python application. The engine is deployed to Azure Container Apps (ACA).
Embeddings are stored in Azure Database for PostgreSQL by using pgvector.
Semantic retrieval uses metadata filtering combined with vector similarity search.
Azure Managed Redis is used as a caching layer.
Front-end and API workloads are deployed to Azure Container Apps (ACA).
Batch model retraining workloads run in Azure Kubernetes Service (AKS).
Container and CI/CD
Container images are stored in Azure Container Registry (ACR).
CI/CD uses ACR Tasks to build images on commit.
ACA environments support revision management.
AKS workloads are deployed by using Kubernetes manifest files stored in Git.
Monitoring
Logs are collected in Azure Monitor.
Teams inspect container logs and Kubernetes events when troubleshooting.
Developers write KQL queries to analyze latency spikes.
Business requirements
Customer experience: Maintain a seamless, low-latency recommendation experience for end- users, even during unpredictable seasonal traffic spikes.
Operational cost efficiency: Minimize compute expenditures by deallocating resources during periods of inactivity and by preventing runaway scaling costs.
Data integrity and freshness: Ensure that product recommendations always reflect the most current catalog metadata and pricing to prevent customer dissatisfaction.
Security and compliance: Adhere to a Zero Trust security model by eliminating long-lived credentials and centralizing the management of all sensitive secrets.
Global scalability: Support the rapid ingestion of millions of new product embeddings daily without degrading query performance for existing retailers.
Technical requirements
Performance: Semantic search latency must remain under 200 milliseconds at peak load.
Database optimization: Use pgvector for embeddings and implement metadata filtering to reduce compute overhead. Configure compute and memory appropriately for vector workloads to ensure high-dimensional index residency in RAM and efficient mathematical throughput. Vector similarity calculations must be performed only against products that satisfy mandatory metadata constraints.
Database performance: Database connections must support high concurrency with minimal latency through the implementation of connection optimization.
Data load strategy: To ensure maximum ingestion throughput, secondary indexes must be applied only after bulk loading of embeddings is complete.
Caching: Redis cache entries must expire automatically after 10 minutes. Implement a reactive mechanism to invalidate cache entries upon metadata updates.
Identity: Use managed identities for all service-to-service and service-to-database authentication.
Plain-text credentials in configuration files are strictly prohibited.
Secret management: All secrets must be stored centrally. Secrets must be rotated automatically by using a centralized lifecycle policy.
Scaling: Use Kubernetes event-driven autoscaling (KEDA) for event-driven scaling. The Recommendation API must scale based on HTTP traffic, while batch jobs must scale based on queue length and support scale-to-zero.
CI/CD: All images must be stored in Azure Container Registry. Use ACR Tasks to automate image builds triggered by source code commits.
Monitoring: Use KQL to analyze performance telemetry and troubleshoot microservice connectivity failures. Inspect logs and events when troubleshooting AKS and ACA.
You need to optimize vector search queries based on the technical requirements. What should you do?
- A. Create an IVFFlat index on the embedding column.
- B. Increase the shared_buffers setting.
- C. Create a B-tree index on metadata filter columns.
- D. Increase the max_connections parameter.
Answer: C
Explanation:
Scenario: Technical requirements
Performance: Semantic search latency must remain under 200 milliseconds at peak load.
*-> Database optimization: Use pgvector for embeddings and implement metadata filtering to reduce compute overhead. Configure compute and memory appropriately for vector workloads to ensure high-dimensional index residency in RAM and efficient mathematical throughput. Vector similarity calculations must be performed only against products that satisfy mandatory metadata constraints.
To optimize vector similarity queries that must be performed only against products satisfying mandatory metadata constraints, you should Create a B-tree index on metadata filter columns.
1. Evaluate Query Execution OrderIn PostgreSQL with pgvector, combining metadata filters with vector similarity searches often triggers a multi-stage execution plan. When metadata filtering is highly restrictive, creating a B-tree index allows the database engine to quickly narrow down the row scanned before or during the vector evaluation, preventing a costly full-table scan.
2. Assess Indexing Trade-offs
B-tree Index (Metadata): Directly addresses the requirement that vector calculations must be performed only against products satisfying mandatory metadata constraints. It optimizes the metadata filtering step, significantly reducing compute overhead and isolating the target rows for vector processing.
IVFFlat Index (Vector): While an IVFFlat index speeds up high-dimensional approximate nearest neighbor (ANN) searches, it divides vectors into lists. If a metadata filter is applied after an IVFFlat index scan, it can lead to severe recall degradation or inaccurate results because rows matching the metadata might reside in unsearched vector lists. (Note: For newer workloads, HNSW is generally preferred over IVFFlat for better recall and performance, but regular B-trees remain vital for the metadata layer).
3. Ensure Index Residency in RAM
By isolating the dataset using a compact B-tree index on metadata columns, you minimize the active working set. This helps fulfill your operational requirement to ensure that high-dimensional vector indexes and target rows remain resident in RAM for efficient mathematical throughput.
Reference:
https://www.applied-ai.com/briefings/enterprise-rag-architecture/
NEW QUESTION # 46
You need to detect whether an uploaded image contains adult or violent content before allowing it to be posted to a public forum. What should you use?
- A. Azure AI Custom Vision object detection
- B. Azure AI Face API
- C. Azure AI Content Safety image moderation
- D. Azure AI Document Intelligence
Answer: C
Explanation:
Azure AI Content Safety's image moderation capability is purpose-built to detect categories such as sexual, violent, self-harm, and hate content in images, returning severity scores you can act on.
NEW QUESTION # 47
You need to secure an Azure OpenAI resource so that it is only reachable from your virtual network and not from the public internet. What should you configure?
- A. Azure AI Content Safety
- B. A private endpoint with Azure Private Link
- C. Cross-Origin Resource Sharing (CORS) rules
- D. API key rotation
Answer: B
Explanation:
Private Link/private endpoints assign the Azure OpenAI resource a private IP within your VNet and allow disabling public network access, ensuring traffic stays on the Microsoft backbone network and isn't reachable from the public internet.
NEW QUESTION # 48
Hotspot Question
You are creating an app that uses Event Grid to connect with other services. Your app's event data will be sent to a serverless function that checks compliance. This function is maintained by your company.
You write a new event subscription at the scope of your resource. The event must be invalidated after a specific period of time.
You need to configure Event Grid.
What should you do? To answer, select the appropriate options in the answer area.
NOTE: Each correct selection is worth one point.
Answer:
Explanation:
Explanation:
Box 1: Key authentication
For secure, authenticated delivery to your company's serverless function, configure the Event Grid subscription using Key authentication. Select WebHook as the endpoint type and set the destination to your serverless function's HTTPS URL.
Box 2: ValidationCode handshake
For topic publishing in this scenario, you should configure Event Grid to use the ValidationCode handshake. This mechanism ensures that the company's compliance Azure Function securely verifies ownership of the endpoint by echoing a specific validation code back to Event Grid when the new subscription is registered at the scope of the resource.
Reference:
https://learn.microsoft.com/en-us/azure/event-grid/security-authorization
NEW QUESTION # 49
Drag and Drop Question
You are developing a .NET application that uses Azure Cosmos DB for NoSQL to store application data.
The application uses the Azure Cosmos DB for NoSQL SDK to interact with the database account.
The application must perform the following tasks:
- Initialize the connection by using the account endpoint and key.
- Define shared throughput.
- Perform create, read, update, and delete (CRUD) operations on items
stored in a container.
You need to implement the SDK components required for the application to access and manage data in Azure Cosmos DB for NoSQL.
Which SDK components should you use? To answer, move the appropriate components to the correct requirements. You may use each component once, more than once, or not at all. You may need to move the split bar between panes or scroll to view content.
NOTE: Each correct selection is worth one point.
Answer:
Explanation:
Explanation:
Box 1: CosmosClient
To initialize the connection to an Azure Cosmos DB for NoSQL account using the account endpoint and key, you must use the CosmosClient class.
Box 2: Database
The database SDK component should be used to define shared throughput.
In Azure Cosmos DB, shared throughput (provisioned Request Units per second or RU/s) is configured at the database level. When throughput is provisioned on a database, that capacity is shared among all the containers created within that specific database.
Box 3: Container
To perform item create, read, update, and delete (CRUD) operations, you should use the Container SDK component In the Azure Cosmos DB for NoSQL SDK for .NET, individual JSON documents (items) live inside a container. The Container class exposes the specific methods required to execute CRUD operations on these items.
Reference:
https://learn.microsoft.com/en-us/azure/cosmos-db/how-to-dotnet-get-started
NEW QUESTION # 50
Case Study 2 - Proseware Inc.
Background
Proseware Inc. develops AI-powered knowledge management solutions for enterprise customers.
The company is modernizing its platform to support semantic search, intelligent document retrieval, and real-time partner integrations.
The engineering team uses Python and Azure SDKs. The architecture is being redesigned to support containerized microservices, vector search workloads, and serverless backend processing.
Planned Application Architecture
Microservices are containerized by using Docker.
Code for containerized microservices and Azure Function apps is developed locally but stored in a GitHub repository.
Custom images for containerized microservices are stored in Azure Container Registry (ACR).
Base images are stored in Docker Hub. Custom images must be rebuilt automatically whenever their base images are updated.
Azure Cosmos DB for NoSQL stores documents, metadata, and vector embeddings.
Azure Functions generate vector embeddings of Azure Cosmos DB for NoSQL-hosted documents and send messages to Service Bus to trigger search index updates.
Azure Container Apps (ACA) apps host backend API services that provide semantic search across Azure Cosmos DB for NoSQL documents. API services process Service Bus messages and update search indexes.
Azure Kubernetes Service (AKS) processes batch vector embedding regeneration for existing Azure Cosmos DB for NoSQL documents (whenever the embedding model is changed).
An extranet-facing containerized webhook allows business partners to submit documents to be processed by internal AI workflows for semantic search and retrieval.
Monitoring
Telemetry generated by Azure resources is sent to Azure Monitor.
A Log Analytics workspace is used to collect ACA apps logs, AKS container logs, and Azure Functions apps logs.
Monitoring of Azure Functions is currently implemented by using Azure Application Insights SDK instrumentation.
Business Requirements
Embeddings for new or updated Azure Cosmos DB for NoSQL-hosted documents must be automatically generated.
Backend API services must scale automatically during business hours.
Cold start delay of backend APIs must be minimized.
Secrets must be stored outside of container images.
Developers must be able to correlate telemetry across Azure Functions hosts and apps.
All tracing must be implemented by using OpenTelemetry SDK instrumentation.
Development efforts must be minimized.
Technical Requirements
Container images must be built automatically and validated before code updates are merged into the main branch.
Image build automation must run inside the Azure Container Registry, eliminating dependency on local developer machines and external build services.
Dependency of image builds on local developer machines must be eliminated.
Event-driven scaling in ACA must occur based on the number of pending messages in the Azure Service Bus queue.
Azure Cosmos DB for NoSQL RU consumption must be minimized.
Vector similarity search must use embeddings stored in Azure Cosmos DB for NoSQL.
The partner-facing containerized webhook service must run on Azure App Service.
Secrets must NOT be stored in container images, source control, or application configuration directly. They must be accessed securely at runtime.
All secrets must be stored centrally in Azure Key Vault and accessed at runtime through a managed identity.
Azure App Service must supply secrets at runtime without relying on external services.
Resources and workloads must be deployed by using Bicep templates through an automated, version-controlled pipeline. Local and command-line deployments must be eliminated to ensure repeatable, auditable deployments.
Known Issues
RU consumption spikes during vector similarity queries.
You need to deploy a batch embedding workload according to the planned application architecture.
What should you use?
- A. YAML-formatted files
- B. XML-formatted files
- C. az aks commands
- D. kubectl run and create commands
Answer: A
Explanation:
Scenario, application architecture
Azure Functions generate vector embeddings of Azure Cosmos DB for NoSQL-hosted documents and send messages to Service Bus to trigger search index updates.
YAML-formatted files should be used for this deployment.
In a production-grade Kubernetes architecture, declarative management using configuration files provides the predictability, version control, and automation required for complex microservices.
Declarative Configuration: Kubernetes relies natively on YAML to define the desired state of resources like Deployments, KEDA ScaledObjects (for event-driven Azure Function scaling), and Secrets.
Complex Deployments: Your workload requires setting up multiple components, environmental variables, and scaling rules that cannot be efficiently managed via single-line commands.
GitOps Readiness: Storing configurations in YAML allows you to track changes in source control and deploy updates automatically through CI/CD pipelines.
Reference:
https://developer.okta.com/blog/2022/05/05/kubernetes-microservices-azure
NEW QUESTION # 51
You are designing an Azure Function that will process orders from a new Azure Service Bus queue.
You need to prevent the system from processing messages more than once and preserve failed messages for investigation.
Which two actions should you implement? Each correct answer presents part of the solution.
NOTE: Each correct selection is worth one point.
- A. Process orders by using an HTTP trigger.
- B. Enable duplicate detection on the queue.
- C. Include a dead-letter handling process.
- D. Enable sessions on Service Bus.
Answer: B,C
Explanation:
To ensure reliable order processing with zero duplicates and safe error handling, you should implement an Azure Function with an Azure Service Bus Trigger utilizing duplicate detection, PeekLock settlement, and custom dead-letter routing.
References:
https://azureintegrations.com/2020/03/01/azure-servce-bus-best-practises/
NEW QUESTION # 52
You store embeddings in Redis by using keys formatted as doc:(id). Some embeddings are accessed frequently. Others are rarely used.
You need to implement a caching strategy that keeps only frequently accessed embeddings in memory.
What should you use?
- A. allkeys-lru
- B. time-window expiration
- C. volatile-ttl
- D. EXPIRE command
Answer: A
Explanation:
To implement this strategy, you should use allkeys-lru combined with the EXPIRE command as a secondary fallback.
Primary Mechanism: Configure your Redis maxmemory-policy to allkeys-lru.
Secondary Mechanism: Apply the EXPIRE command to your keys as a safety net.
Why allkeys-lru is the Best Choice
Memory Management: It automatically evicts the Least Recently Used (LRU) keys across your entire dataset when Redis hits its memory limit.
Frequent Access: It guarantees that frequently accessed embeddings stay in memory, regardless of when they were created.Prefix Independent: It scans all keys, making it perfect for your doc:(id) format Reference:
https://rahulchowdhury.in/blog/redis-caching-patterns-every-mern-dev
NEW QUESTION # 53
An application performs similarity search across 5 million embeddings stored in Azure Database for PostgreSQL with pgvector. Queries often filter by department before ranking by cosine distance.
P95 latency for vector similarity queries exceeds the SLA target. Monitoring shows sustained high CPU use during query execution.
You need to reduce P95 latency for filtered vector similarity queries.
What should you do?
- A. Increase embedding dimensionality.
- B. Store embeddings as JSON.
- C. Create B-tree indexes on frequently filtered metadata columns.
- D. Increase statement timeout.
Answer: C
Explanation:
Creating a B-tree index on the department column will help, but only if you use the correct indexing strategy, as a standard B-tree index alone is often ignored during vector searches.
When you run a query that filters by metadata before performing a vector similarity search, PostgreSQL must choose between filtering the rows first or searching the vector index first. In many cases, a standard B-tree index on the metadata column combined with an HNSW/IVFFlat index on the vector column results in pre-filtering that defaults to a sequential scan, or post- filtering that returns fewer results than requested.
Reference:
https://learn.microsoft.com/en-us/azure/horizondb/ai/vector-search-pgvector
NEW QUESTION # 54
Your application must classify uploaded product images into one of 40 custom categories specific to your business (e.g., proprietary part numbers). What should you use?
- A. Azure AI Custom Vision (image classification)
- B. Azure AI Face API
- C. Azure AI Vision prebuilt image analysis
- D. Azure AI Document Intelligence
Answer: A
Explanation:
Prebuilt Vision models recognize general objects/scenes but not business-specific categories.
Custom Vision allows you to train a classifier on your own labeled images for domain-specific categories such as proprietary part numbers.
NEW QUESTION # 55
You are evaluating a fine-tuned Azure OpenAI model against the base model before promoting it to production. Which Azure AI Foundry capability should you use?
- A. Azure AI Search indexer scheduling
- B. Azure Monitor Application Insights only
- C. Prompt flow bulk testing / evaluation with metrics (groundedness, coherence, relevance)
- D. Content Safety category configuration
Answer: C
Explanation:
Azure AI Foundry's evaluation tooling (often via prompt flow or the Evaluation SDK) runs bulk test sets against both models and scores outputs on metrics like groundedness, coherence, and relevance, enabling an objective comparison before promotion.
NEW QUESTION # 56
You need to ensure that responses from your Azure OpenAI application include citations back to the specific source documents used, to support user trust and verification. What should you implement?
- A. Use only the base model with no retrieval
- B. Enable higher content filter severity
- C. Configure the RAG pipeline to return retrieved document metadata (source, page) alongside generated answers and instruct the model to cite them
- D. Increase top_p to broaden token sampling
Answer: C
Explanation:
Citation support requires passing document metadata (source name, page/section) through the retrieval step and prompting the model to reference that metadata explicitly in its answer -- this is a pipeline and prompt design pattern, not a sampling parameter.
NEW QUESTION # 57
Drag and Drop Question
You are deploying an Azure Function app that retrieves secrets from Key Vault by using a managed identity.
The deployment must ensure that identity and secret configuration are in place before the function code is deployed.
You need to deploy the function app securely.
In which order should you perform the actions? To answer, move all actions from the list of actions to the answer area and arrange them in the correct order.
Answer:
Explanation:
Explanation:
Step 1: Create the function app
You must first provision the underlying Azure Functions infrastructure before you can bind an identity or configuration settings to it.
Step 2: Assign a managed identity to the function app
Turning on the managed identity (such as a system-assigned identity) creates a distinct security principal in Microsoft Entra ID for the resource.
Step 3: Grant access to Key Vault
Use the managed identity's principal ID to create an access policy or RBAC role assignment in Key Vault, allowing the app to read secrets.
Step 4: Add Key Vault references to application settings.
Configure the Function App's application settings to point to the Key Vault secret URIs (@Microsoft.KeyVault(...)), which can now be securely resolved by the identity.
Step 5: Deploy the function code
Finally, deploy the application code. This ensures that when the code initializes and executes, all environment variables and secrets are already active and accessible, preventing application startup failures.
Reference:
https://learn.microsoft.com/en-us/azure/app-service/app-service-key-vault-references
NEW QUESTION # 58
Hotspot Question
You are reviewing the Python tracing configuration for an application that must send distributed traces to Azure Monitor.
The following code configures OpenTelemetry tracing:
For each of the following statements, select Yes if the statement is true. Otherwise, select No.
NOTE: Each correct selection is worth one point.
Answer:
Explanation:
Explanation:
Box 1: Yes
Yes, the code configures the tracer provider before any spans are created.
While the tracer provider initialization sequence is structurally correct, no spans can be captured yet at the moment the tracer instance is fetched because the processor and exporter are attached too late in the execution flow.
Box 2: No
No, this configuration does not export traces synchronously.
The code utilizes BatchSpanProcessor, which batches completed spans and exports them asynchronously on a background thread to prevent telemetry collection from blocking your main application code.
Box 3: Yes
Yes, this configuration successfully enables the export of distributed traces to Azure Monitor.
The code provided correctly initializes and wires up the native OpenTelemetry SDK components with the official Azure Monitor exporter library.
Reference:
https://learn.microsoft.com/en-us/python/api/overview/azure/monitor-opentelemetry-exporter-readme
NEW QUESTION # 59
Your solution must answer questions about numeric data in large Excel-based reports (e.g.,
"What was Q3 revenue for the West region?"). Which approach is most appropriate?
- A. Rely on the model's parametric knowledge
- B. Store the Excel data as unstructured text and embed it for vector search
- C. Use Azure AI Vision to read the spreadsheet as an image
- D. Convert data to a structured table/SQL source and use a function-calling agent to query it
Answer: D
Explanation:
Precise numeric/tabular lookups are handled poorly by vector similarity search or free-text embedding of numbers. Structuring the data (e.g., in a database) and letting a function-calling agent issue precise queries yields accurate, verifiable answers.
NEW QUESTION # 60
Hotspot Question
You are implementing semantic retrieval in Redis.
The solution must support low-latency, approximate nearest neighbor (ANN) vector similarity search for large-scale AI retrieval workloads.
You need to select the appropriate vector schema settings.
Which configuration values should you select? To answer, select the appropriate options in the answer area.
NOTE: Each correct selection is worth one point.
Answer:
Explanation:
Explanation:
Box 1: Vector
The correct field type for storing and querying embeddings in Redis is VECTOR.
Box 2: HNSW index
To support low-latency, large-scale approximate nearest neighbor (ANN) vector search in Redis, you should use the HNSW (Hierarchical Navigable Small World) index type with Float32 data type.
Reference:
https://redis.io/docs/latest/develop/ai/search-and-query/vectors/
NEW QUESTION # 61
You are choosing an embedding strategy for a RAG solution. Documents range from 2 to 200 pages. You need to preserve semantic coherence while staying within embedding model token limits. What should you do?
- A. Embed each entire document as a single vector
- B. Convert documents to images and use image embeddings
- C. Use only document titles for embedding
- D. Chunk documents into smaller overlapping segments before embedding
Answer: D
Explanation:
Embedding models have token limits, and embedding an entire long document as one vector dilutes semantic meaning. Chunking into smaller, slightly overlapping segments preserves context at chunk boundaries and keeps each chunk within model limits while improving retrieval relevance.
NEW QUESTION # 62
Hotspot Question
You are developing an application that uses a Python API to perform similarity queries against Azure Database for PostgreSQL. The application creates a new database connection for every request.
During peak traffic, the application intermittently fails to open new database sessions. Logs indicate that the maximum number of connections have been reached.
You need to configure the connection pooling strategy to reduce connection setup overhead and maximize reuse for the high-concurrency workload.
What should you configure? To answer, select the appropriate options in the answer area.
NOTE: Each correct selection is worth one point.
Answer:
Explanation:
Explanation:
Box 1: PgBouncer
To resolve the connection exhaustion issue, you should use the built-in PgBouncer connection pooler configured in Transaction Pooling mode.
Because PostgreSQL uses a process-per-connection architecture, opening and closing a new session for every API request causes massive CPU/memory overhead and rapidly drains available slots during traffic spikes Box 2: Transaction Pooling mode Reference:
https://learn.microsoft.com/en-us/azure/postgresql/connectivity/concepts-connection-pooling-best-practices
NEW QUESTION # 63
You must ensure an Azure OpenAI-powered application never exceeds a defined token-per- minute budget across all users to avoid runaway costs. What should you configure?
- A. Content filtering severity levels
- B. Deployment-level rate limits (TPM/RPM) in Azure AI Foundry
- C. Model temperature
- D. A vector index size limit in Azure AI Search
Answer: B
Explanation:
Each Azure OpenAI deployment can have Tokens-Per-Minute (TPM) and Requests-Per-Minute (RPM) limits configured, which cap consumption at the deployment level and directly control cost exposure.
NEW QUESTION # 64
Hotspot Question
You plan to develop an Azure Functions app with an HTTP trigger.
The app must support the following functionality:
- Event-driven scaling
- Ability to use custom Linux images for function execution
You need to identify the app's hosting plan and the maximum amount of time that the app function can take to respond to incoming requests.
Which configuration setting values should you use? To answer, select the appropriate values in the answer area.
NOTE: Each correct selection is worth one point.
Answer:
Explanation:
Explanation:
Box 1: Premium
To fulfill your requirements, you should use the Azure Functions Premium plan (also known as the Elastic Premium plan).
Event-Driven Scaling: It features dynamic, automatic scale-out driven by the Azure scale controller. It can scale down to zero instances when idle, ensuring you only pay for active compute time.
Custom Linux Images: Unlike the base Consumption plan, the Premium plan allows you to deploy and run your functions inside a custom Linux container image. This lets you bring your own custom OS dependencies, specialized tools, or specific runtime environments.
Box 2: 230 seconds
The correct maximum timeout value to use for an HTTP-triggered function is 230 seconds.
Azure Load Balancer Limit: Regardless of the specific Azure Functions hosting plan or timeout configurations you set in host.json, the Azure Functions Scale and Hosting documentation states that an HTTP-triggered function has a hard limit of 230 seconds to respond to a request.
Idle Timeout: This constraint is strictly enforced due to the default idle timeout of the underlying Azure Load Balancer. If your function runs longer than 230 seconds without returning a response, the connection will be dropped, resulting in a timeout error.
Reference:
https://learn.microsoft.com/en-us/azure/azure-functions/functions-deployment-technologies
https://learn.microsoft.com/en-us/azure/azure-functions/functions-scale
NEW QUESTION # 65
Drag and Drop Question
You are developing several microservices to run on Azure Container Apps.
The microservices must allow HTTPS access by using a custom domain.
You need to configure the custom domain in Azure Container Apps.
In which order should you perform the actions? To answer, move all actions from the list of actions to the answer area and arrange them in the correct order.
Answer:
Explanation:
Explanation:
Step 1: Enable ingress
You must first expose your container app to external traffic to generate the default fully qualified domain name (FQDN) needed for DNS mapping.
Step 2: Add DNS records to the domain provider
Log into your domain registrar to create the required TXT (for verification) and CNAME/A records pointing to your container app.
Step 3: Validate the custom domain name
Azure checks your DNS records to confirm that you actually own the domain before allowing it to be linked.
Step 4: Add the custom domain name
Once validation passes, you officially add and register the custom domain name within the Azure Container App configuration.
Step 5: Bind the certificate
Finally, bind an SSL/TLS certificate to the custom domain to secure the connection and enable HTTPS access.
Reference:
https://learn.microsoft.com/en-us/azure/container-apps/ingress-overview
NEW QUESTION # 66
You are developing an AI-powered API that retrieves connection strings and API keys from Azure Key Vault.
You must configure a solution that provides the following security functionality:
- The API must authenticate to Key Vault without storing credentials in any application configuration files.
- The identity used by the API must have only the minimum permissions
necessary to read secrets.
- The configuration must minimize the blast radius if an identity or
credential is compromised.
You need to implement a secure access strategy for the API.
Which two actions should you perform? Each correct answer presents part of the solution.
NOTE: Each correct selection is worth one point.
- A. Grant the Key Vault Secrets User role at vault scope.
- B. Assign the Key Vault Administrator role at subscription scope.
- C. Store a secret value in Azure App Configuration.
- D. Use system-assigned managed identity.
Answer: A,D
Explanation:
You should use a system-assigned managed identity, but to minimize the blast radius, you should grant the Key Vault Secrets User role at the secret scope rather than the vault scope.
Authentication (Managed Identity): A system-assigned managed identity perfectly satisfies your first requirement. Azure automatically manages the identity credentials, eliminating the need to store keys or connection strings in application configuration files. Because it shares the lifecycle of your API service, it is automatically deleted if the API is removed.
Authorization (RBAC Role): The Key Vault Secrets User role satisfies the "minimum permissions" requirement because it only grants read permissions (Microsoft.KeyVault/vaults/secrets/getSecret/action and readSecret/action.
Scope (Blast Radius Minimization): Granting this role at the vault scope allows the API to read every secret inside that vault. If your API only needs specific connection strings, you should grant the role at the individual secret scope [0.30]. This restricts the identity so it cannot access any other secrets in the vault if compromised.
Reference:
https://learn.microsoft.com/en-us/azure/api-management/api-management-howto-use-managed-service-identity
NEW QUESTION # 67
......
Updated Verified AI-200 dumps Q&As - Pass Guarantee or Full Refund: https://prepaway.vcetorrent.com/AI-200-valid-vce-torrent.html