1. AI-102 Topic 1 Question 7
Question
DRAG DROP -
You plan to use containerized versions of the Anomaly Detector API on local devices for testing and in on-premises datacenters.
You need to ensure that the containerized deployments meet the following requirements:
✑ Prevent billing and API information from being stored in the command-line histories of the devices that run the container.
✑ Control access to the container images by using Azure role-based access control (Azure RBAC).
Which four actions should you perform in sequence? To answer, move the appropriate actions from the list of actions to the answer area and arrange them in the correct order.
NOTE: More than one order of answer choices is correct. You will receive credit for any of the correct orders you select.
Select and Place:
Suggested Answer


Comment 1
I think the it should be:
1. Create a custom docker file
2. Pull the container image (in the dockerfile)
3. Build the image
4 Push to ACR
Comment 1.1
1 - the custom dockerfile prevents the billing information from being stored in commandline histories
2 - pull and build are necessary to take into account the requirements defined in the dockerfile
3 - Push to acr where we can define RBAC access rules to the new image
Comment 2
ChatGPT: To meet the requirements, perform the following actions in sequence:
1. Create a custom Dockerfile: This allows you to define the specific configuration and dependencies for your containerized deployment.
2. Build the image: Use the Dockerfile to build the container image with the necessary components and configurations.
3. Push the image to an Azure container registry: Store the container image in an Azure container registry to control access and ensure secure storage.
4. Distribute a docker run script: Provide a docker run script that can be used to run the containerized deployment on local devices or in on-premises datacenters. This script should include any necessary environment variables or configuration settings.
Note: The actions of pulling the Anomaly Detector container image and pushing the image to Docker Hub are not mentioned in the requirements. Therefore, they are not necessary for meeting the given requirements.
Comment 3
Microsoft Co-Pilot said Pull the Anomaly Detector container image is the starting point. See: https://learn.microsoft.com/en-us/azure/ai-services/anomaly-detector/anomaly-detector-container-howto Then you can Create a custom Dockerfile
Comment 4
Pull the Anomaly Detector container image: first obtain the official base image from the Microsoft Container Registry.
Create a custom Dockerfile: To prevent secrets from appearing in CLI history
Build the image: To processes the Dockerfile and creates "hardened" version of the container locally.
Push the image to an Azure container registry: Azure Container Registry (ACR) supports Azure RBAC.
Comment 5
it should be like this steps?
Create a custom Dockerfile
Pull the Anomaly Detector Container Image
Build the Image
Push the image to an Azure Container registry
Comment 6
Incorrect. Correct answer is:
1. Create custom docker file (as it includes instructions to pull the latest image of anomaly detector)
2. Build the image
3. Push to ACR
4. Distribute Docker Run
Comment 7
Pull the Anomaly Detector container image (b):
Start by retrieving the official Anomaly Detector container image from a registry. You can use the docker pull command to download it.
Create a custom Dockerfile (a):
Next, create a custom Dockerfile that defines the instructions for building your specific image. Customize it to include your requirements, such as preventing sensitive information from being stored in command-line histories.
Build the image (e):
Use the Dockerfile to build your custom image. This step compiles the necessary components and configurations.
Push the image to an Azure container registry (d):
Finally, store your custom image in an Azure container registry. This ensures controlled access and secure storage.
Comment 8
1. Create a custom docker file
2. Pull the container image (in the dockerfile)
3. Build the image
4 Push to ACR
This is highly voted answer. Is it correct?....pls help
Comment 9
This is the right one:
1. Pull the Anomaly Detector container image.
2. Create a custom Dockerfile.
3. Build the image.
4. Push the image to an Azure container registry.
Comment 10
1. Pull the anomaly detector
2. build docker file
3. build image
4. publish to ACR
this now will become source for all devices to pull the image and run from ACR.
Comment 11
1.Create a custom Dockerfile
2.Build the image
3.Push the image to an Azure container registry
4.Distribute a docker run script
From Takedajuku perspective, if you study for 4 days and spend 2 days reviewing, you will have a better chance of passing the exam.
Comment 12
it is important to note NOTE: More than one order of answer choices is correct.
Comment 12.1
you rock, this shows that we have to read carefully the question
Comment 13
1. Pull the image
2. Create dockerfile
3. Build
4. Run
5. Push to ACR if required
Comment 13.1
while this order is fine technically, after reading the question again i think it is important to push the image to ACR to manage RBAC..So skipping the docker pull and instead pull directly from MCR in the dockerfile is better so my 4 choices are below
1. Create dockerfile
2. Build
3. Push to ACR if required
4. Run
Comment 14
1. Create.
2. Build.
3. Push
4. Run
Instruction example hello-world image
https://learn.microsoft.com/en-us/azure/container-registry/container-registry-quickstart-task-cli
Comment 14.1
Yeah, but instructions say "datacenters" - plural. That means basically that step "Distribute a docker run script" is there for a reason.
Comment 15
Final Answer:
1.Create a custom Dockerfile
2.Build the image
3.Push the image to an Azure container registry
4.Distribute a docker run script:
Comment 16
I think the it should be:
1. Pull the container image (in the dockerfile)
2. Create a custom docker file
3. Build the image
4 Push to ACR
Comment 17
check Azure official on youtube: https://www.youtube.com/watch?v=XLQLNazid4I
The steps should be
1. Pull the container image (in the dockerfile)
2. Create a custom docker file
3. Build the image
4 Push to ACR