With the rapid development of science and technology today, people's work can gradually be replaced by machines. If you are an unemployed person, our study materials also should be the best choice for you. AI-200 Quiz torrent can help you calm down and learn more knowledge of it, and what most important is that our study materials can help you use the shortest time to reach to the top of your career. What are you waiting for? Come and buy it now!
| Section | Objectives |
|---|---|
| Topic 1: Connect to and consume Azure services | - Integrate Azure services
|
| Topic 2: Develop containerized solutions on Azure | - Implement containerized applications
|
| Topic 3: Develop AI solutions by using Azure data management services | - Work with Azure data platforms for AI workloads
|
| Topic 4: Secure, monitor, troubleshoot Azure solutions | - Operate AI cloud solutions
|
The pass rate is 98.65% for AI-200 study guide, and you can pass the exam just one time. In order to build up your confidence for the exam, we are pass guarantee and money back guarantee. If you fail to pass the exam by using AI-200 exam braindumps of us, we will give you full refund. Besides, AI-200 learning materials are edited and verified by professional specialists, and therefore the quality can be guaranteed, and you can use them at ease. We have online and offline service. If you have any questions for AI-200 Exam Materials, you can consult us, and we will give you reply as quick as possible.
NEW QUESTION # 32
You need to troubleshoot connectivity failures between microservices running in AKS.
Which troubleshooting actions should you perform? To answer, move the appropriate action to the correct troubleshooting scenario. You may use each action 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:
* Service fails to communicate with another service: Inspect Kubernetes service endpoints.
* Pod restarts repeatedly: Inspect container logs.
* Readiness probe failures are observed: Inspect Pod descriptions.
For a service-to-service communication failure , first inspect the Kubernetes service endpoints . Microsoft' s AKS troubleshooting guidance recommends verifying that the destination pod IP address and application port appear as endpoints for the Kubernetes Service. An empty or incorrect endpoint list commonly indicates a selector/label mismatch, incorrect port configuration, or unavailable backend pods.
For a pod that restarts repeatedly , inspect the container logs , including the previous container instance when necessary. Microsoft specifically recommends kubectl logs < pod > --previous for workloads that repeatedly restart because it exposes application errors and termination messages from the container immediately before the restart.
For readiness probe failures , inspect the Pod description by using kubectl describe pod. The description exposes the configured health probes, pod conditions, container state, and associated probe-failure events, allowing you to determine whether the probe path, port, timing, or application readiness behavior is incorrect.
Microsoft recommends reviewing kubectl describe output when pods are not Ready or health probes are failing.
Therefore, the correct mapping is service endpoints # container logs # Pod descriptions .
Study Guide references: AKS troubleshooting; Kubernetes Services and endpoints; container logging; Pod health; readiness/liveness probes; kubectl describe and kubectl logs.
NEW QUESTION # 33
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 # 34
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.
Hotspot Question
You need to deploy a batch retraining workload.
How should you complete the scaling configuration? To answer, select the appropriate options in the answer area.
NOTE: Each correct selection is worth one point.
Answer:
Explanation:
Explanation:
Box 1: Azure Service Bus scaler
An Azure Service Bus scaler needs to be set up to meet this requirement.
Queue-Depth Metrics: To trigger scaling based strictly on queue depth, the orchestration layer (such as Azure Container Apps or AKS using KEDA) requires a scaler that can natively communicate with the message broker and monitor metrics like active message count.
Scale-to-Zero Support: Unlike standard resource scalers, an Azure Service Bus scaler enables event-driven batch workloads to spin up consumers when messages arrive and scale all the way down to zero instances when the queue is completely empty.
Box 2: Minimum replicas = 0.
You need to set Minimum replicas = 0.
Setting the minimum replicas to 0 enables the system to scale down to zero instances when there are no messages left in the queue, completely deallocating resources and eliminating idle compute costs.
Box 3: Maximum replicas = 10
To prevent uncontrolled burst scaling during your batch retraining workloads, you need to set maximum replicas = 10.
Enforcing Upper Bounds: Allowing the system to determine the maximum replica gives the underlying autoscaler (such as KEDA or the Horizontal Pod Autoscaler in Azure Kubernetes Service) the freedom to scale out infinitely or up to large default platform limits. This directly risks uncontrolled burst scaling when a massive batch queue is processed.
Resource and Cost Protection: Hard-coding a ceiling (like maximum replicas = 10) ensures that the batch workload cannot consume more cluster resources than allocated, preventing resource starvation for customer-facing recommendation APIs and keeping operational costs predictable.
Reference:
https://azure.github.io/aca-dotnet-workshop/aca/09-aca-autoscale-keda/
https://kserve.github.io/website/docs/reference/crd-api
NEW QUESTION # 35
You are investigating high latency in an AI search application that processes millions of requests daily.
Telemetry is stored in Azure Monitor Logs.
You must create a KQL query that correlates information from the AppRequests table and the AppDependencies table. The query must meet the following requirements:
* Include only data from the last 24 hours.
* Filter for failed requests only.
* Calculate the average duration of dependencies, grouped by operation.
The query must follow best practice to optimize the performance by minimizing the initial data scan.
You need to create the query.
In which order should 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:
Verified Answer: 1) Select the requests table; 2) apply the 24-hour time filter; 3) filter failed requests; 4) join the dependencies table; 5) summarize average dependency duration by operation.
Detailed Explanation: KQL performs best when high-selectivity filters are applied as early as possible, especially the time predicate that limits the amount of data scanned. Starting from AppRequests, restricting to the last 24 hours, and then filtering failures reduces the left-side dataset before the join. The dependency table is then correlated with those requests, and aggregation is performed last to calculate average dependency duration by operation. Joining or summarizing before the time and failure filters would process more data than necessary.
Study Guide Alignment: Security and operations: Key Vault, App Configuration, managed identity, OpenTelemetry, Azure Monitor, and KQL-based troubleshooting.
Official Microsoft Learn References: AI-200 Study Guide | Optimize log queries in Azure Monitor
NEW QUESTION # 36
Note: This question is part of a series of questions that present the same scenario. Each question in the series contains a unique solution that might meet the stated goals.
You are preparing a production deployment for an Azure Function app. The app will run across multiple environments.
The solution must support environment-specific configuration and prevent secrets from being stored in source control.
You need to develop the solution.
Solution: Store connection strings in the Function app application settings configured in the Azure Portal.
Does the solution meet the goal?
Answer: A
Explanation:
Azure Functions application settings are the correct mechanism for keeping environment-specific configuration outside the application source code. Microsoft documents that application settings, including connection strings and other configuration values, are defined separately for each function app . This allows development, test, staging, and production deployments to use different values without modifying the application code.
At runtime, Function app settings are exposed to the application as environment variables , so code can retrieve the required connection string or configuration value without embedding it in a configuration file committed to source control. This directly satisfies the requirement to prevent secrets from being stored in the Git repository.
For production-grade secret management, Azure Key Vault references are often preferable because they provide centralized secret lifecycle management and can be combined with managed identities. However, the question asks only whether the proposed solution meets the stated goals. Storing connection strings in Azure Function application settings does satisfy both: values can vary by deployed environment and remain outside source-controlled application files.
Study Guide references: Azure Functions configuration; application settings; environment variables; secure application configuration.
NEW QUESTION # 37
......
With all the questons and answers of our Microsoft AI-200 study materials, your success is guaranteed. Moreover, we have Demos as freebies. The free demos give you a prove-evident and educated guess about the content of our Developing AI Cloud Solutions on Azure AI-200 Practice Questions. As long as you make up your mind on this AI-200 exam, you can realize their profession is unquestionable.
Exam AI-200 Cost: https://www.edudump.com/exams/Microsoft/AI-200/