Experts hired by AI-200 exam questions not only conducted in-depth research on the prediction of test questions, but also made great breakthroughs in learning methods. With AI-200 training materials, you can easily memorize all important points of knowledge without rigid endorsements. With AI-200 exam torrent, you no longer need to spend money to hire a dedicated tutor to explain it to you, even if you are a rookie of the industry, you can understand everything in the materials without any obstacles. With AI-200 Exam Questions, your teacher is no longer one person, but a large team of experts who can help you solve all the problems you have encountered in the learning process.
| Section | Objectives |
|---|---|
| Connect to and consume Azure services | - Integrate Azure services
|
| Develop AI solutions by using Azure data management services | - Work with Azure data platforms for AI workloads
|
| Develop containerized solutions on Azure | - Implement containerized applications
|
| Secure, monitor, troubleshoot Azure solutions | - Operate AI cloud solutions
|
>> Visual Microsoft AI-200 Cert Exam <<
Our Actual4Dumps's AI-200 exam dumps and answers are researched by experienced IT team experts. These AI-200 test training materials are the most accurate in current market. You can download AI-200 free demo on Actual4Dumps.COM, it will be a good helper to help you pass AI-200 certification exam.
NEW QUESTION # 140
Drag and Drop Question
You plan to create a Docker image that runs an ASP.NET Core application named ContosoApp.
You have a setup script named setupScript.ps1 and a series of application files including ContosoApp.dll.
You need to create a Dockerfile document that meets the following requirements:
- Call setupScript.ps1 when the container is built.
- Run ContosoApp.dll when the container starts.
The Dockerfile document must be created in the same folder where ContosoApp.dll and setupScript.ps1 are stored.
Which five commands should you use to develop the solution? To answer, move the appropriate commands from the list of commands to the answer area and arrange them in the correct order.
Answer:
Explanation:
Explanation:
Step 1: FROM microsoft/aspnetcore:latest
Sets the base image for the container.
Base First: You must always declare the base image (FROM) before running any other commands.
Step 2: WORKDIR /apps/ContosoApp
Creates and sets the working directory inside the container.
Directory and Copy: You need to set the working directory (WORKDIR) before copying files (COPY) so Docker knows exactly where to put them.
Step 3: COPY ./ .
Copies the application files and script from your local folder into the working directory.
Step 4: RUN powershell ./setupScript.ps1
Executes the script during the image build process.
Build vs. Run: The RUN command happens while building the image, so the script completes its setup before the final image is saved. The CMD instruction does not execute anything during the build; it simply configures the starting point for when the container is actually launched.
Step 5: CMD ["dotnet", "ContosoApp.dll"]
Defines the default command to run your application when the container starts.
Reference:
https://azuretar.com/using-startup-command-to-pass-command-line-arguments-to-azure-app-service-for-linux/
NEW QUESTION # 141
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 # 142
You need to configure the database resources for the Azure Database for PostgreSQL instance.
How should you complete the configuration to meet the business and technical requirements? To answer, select the appropriate options in the answer area.
NOTE: Each correct selection is worth one point.
Answer:
Explanation:
Explanation:
* Meet the 200-ms semantic search latency requirement: Increase compute vCores.
* Optimize the environment for high-dimensional pgvector index residency: Increase memory allocation.
* Support the continuous ingestion of transaction-based embeddings: Enable storage autoscale.
For the strict sub-200-ms vector-search latency target, increasing compute vCores is the appropriate choice.
Vector similarity operations are computationally intensive, and additional CPU capacity improves mathematical throughput and parallel query execution. Microsoft's pgvector guidance emphasizes query-plan optimization, ANN indexes such as HNSW, and sufficient compute resources when optimizing vector workloads.
For high-dimensional pgvector index residency , increase memory allocation . HNSW provides strong query-performance characteristics but consumes more memory than IVFFlat. Keeping frequently accessed vector index structures in memory minimizes disk access and materially improves latency. Microsoft explicitly notes that HNSW requires more memory while providing a better speed/recall tradeoff.
For the continuous ingestion of millions of embeddings, enable storage autoscale . Azure Database for PostgreSQL Flexible Server can automatically increase allocated storage as capacity approaches configured thresholds, avoiding an out-of-storage condition as data volumes grow. Microsoft recommends storage autogrow for workloads whose storage demand can increase dynamically.
Increasing max_connections does not directly improve vector computation or index residency, read replicas primarily scale reads, and backup retention does not address ingestion capacity.
Study Guide references: Azure Database for PostgreSQL Flexible Server # pgvector performance optimization; compute and memory sizing; HNSW indexing; storage autogrow.
NEW QUESTION # 143
You are developing a microservices-based application that uses Azure Container Apps. The application consists of several containerized services that handle tasks, such as processing orders, managing inventory, and generating reports. You deploy a new revision of the processing orders app.
Processing orders must be triggered by a web request and must always be available based on incoming web requests.
You need to validate that the replica is ready to handle incoming requests.
What should you implement?
Answer: E
Explanation:
Detailed Explanation: A readiness probe answers whether a running replica is currently ready to receive traffic. For a web-triggered order-processing service, an HTTP readiness probe can test the application endpoint and keep the replica out of the routing pool until it is able to handle requests. Liveness probes detect whether the process should be restarted, and startup probes protect slow-starting containers during initialization. A TCP readiness probe can test socket acceptance, but the HTTP readiness probe is the more application-aware choice for the HTTP service described.
Study Guide Alignment: Containerized Azure workloads: registry builds, App Service containers, Container Apps revision/scaling behavior, and AKS deployment choices.
Official Microsoft Learn References: AI-200 Study Guide | Health probes in Azure Container Apps
NEW QUESTION # 144
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.
Drag and Drop Question
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:
Box 1: Inspect Pod descriptions
Inspecting Pod descriptions is an excellent and standard first troubleshooting step to fix inter- service communication failures in Azure Kubernetes Service (AKS).
To remedy a communication failure between containerized microservices in Azure Kubernetes Service (AKS), the first and most direct troubleshooting action is to verify and debug core Kubernetes networking and DNS resolution within the cluster.
1. Check Pod Status: Ensure both the source and target pods are actively running.
Run kubectl get pods -n <namespace> to check for crash loops.
2. Verify DNS Resolution
Etc.
Box 2: Inspect Pod descriptions
To troubleshoot sudden or frequent Pod restarts in Azure Kubernetes Service (AKS), you should inspect Pod descriptions first, as they contain the Last State, Exit Code, and Reason (such as OOMKilled) for the restarted container.
Pod descriptions (Correct Choice): This is the best starting point. Running kubectl describe pod
<pod-name> provides a comprehensive status overview. It specifically reveals the Last State of the container, the Exit Code, and the Termination Reason (e.g., OOMKilled if it exceeded memory limits, or Error). It also displays the Pod's recent lifecycle events at the bottom.
Incorrect:
Container logs: While highly valuable, logs are only useful if the application managed to write an error message to stdout or stderr before crashing. If a Pod is killed externally by the system (such as an Out-Of-Memory event), the container logs will suddenly stop without showing the root cause.
Box 3: Inspect Pod descriptions
To address readiness probe failures, the most immediate and effective troubleshooting action is to inspect the Pod descriptions.
Pod descriptions: This is the correct starting point. Running kubectl describe pod <pod-name> provides a dedicated Events section at the bottom of the output. This section explicitly details exactly why a readiness probe failed, including the specific error codes, timeouts, or connection refusals, and lists the exact timestamps of the failures.
Reference:
https://blog.devgenius.io/k8s-troubleshooting-pod-in-containercreating-status-e89e093d996e?gi=e4e93cbfd5d6
https://learn.microsoft.com/en-us/troubleshoot/azure/azure-kubernetes/availability-performance/troubleshoot-oomkilled-aks-clusters
NEW QUESTION # 145
......
Entering a strange environment, we will inevitably be very nervous. And our emotions will affect our performance. That is why some of the condidats fail in their real exam. But if you buy our AI-200 exam questions, then you won't worry about this problem. Our AI-200 study guide has arranged a mock exam to ensure that the user can take the exam in the best possible state. We simulated the most realistic examination room environment so that users can really familiarize themselves with the examination room. And our AI-200 Practice Engine can give you 100% pass guarantee.
AI-200 Exam Experience: https://www.actual4dumps.com/AI-200-study-material.html