Pass Your Microsoft AZ-104 Exam Easy!

Changing charts can reveal useful details about peak traffic, concurrency and response times, but it does not change how many replicas the Container Apps revision can create. The given rule is already at maxReplicas=2 during the high-latency period. If healthy instances are capacity-constrained, the administrator needs to evaluate a higher supported maximum and the HTTP concurrency target, then measure the result. New dashboards alone leave the binding scale ceiling intact, so they cannot supply the additional service capacity requested in the question.

A Service Bus scaler is designed to react to queue depth or another supported event source. The application in the question receives HTTP requests and has no stated Service Bus queue. Adding a queue trigger would not characterize the existing inbound HTTP concurrency or resolve a two-replica cap caused by the current HTTP scale configuration. Event-driven queue scaling is relevant to worker applications that actually consume such messages; this service instead needs measured adjustment of its HTTP rule and allowed replica maximum. Use the trigger that corresponds to the traffic actually described.

Valid image-pull credentials are necessary for new replicas to start, but the existing revision has two healthy running replicas and no image-pull errors. Replacing successful registry credentials cannot by itself raise the maximum replica count or change the HTTP concurrency threshold that determines scale-out. Credential investigation would be relevant for failing revision starts or authorization errors, neither of which is present in the scenario. The material symptom is peak requests encountering a capacity ceiling, not an inability to retrieve the container image.

Lowering minReplicas from one to zero may reduce idle charges when the application has no requests, but it does not increase the maxReplicas=2 ceiling already reached during peaks. It can also introduce cold-start considerations when traffic resumes. The question explicitly asks for additional capacity under a healthy but saturated two-replica revision, not lower idle cost. Keep the scaling goal separate from another practice scenario's idle scale-to-zero objective: this case requires raising the maximum and tuning HTTP thresholds based on observed demand, not changing only the floor.

When a team proposes a single large ACI container for intermittent unpredictable HTTP demand rather than using managed autoscaling, the action 'Evaluate Container Apps replica scaling versus fixed ACI group sizing' can be relevant: ACI sizes a container group; Container Apps can add replicas based on configured triggers. For the different problem of a Container Apps endpoint has large traffic spikes but can scale down overnight, 'Evaluate Container Apps replica scaling versus fixed ACI group sizing' misses the mechanism that minimum determines warm capacity; maximum caps expansion under scaling triggers. Choosing 'Evaluate Container Apps replica scaling versus fixed ACI group sizing' would address that other need, whereas 'Configure a supported HTTP scaling rule with minReplicas=0 and a tested maxReplicas sized for daytime peaks, then monitor scale behavior' is intended to solve the stated condition.

'Use Azure Container Apps rather than a one-off ACI container group' applies to a different feature boundary because container Apps supports managed ingress, revisions and scaling rules for service workloads. In the stated scenario where a Container Apps endpoint has large traffic spikes but can scale down overnight, 'Use Azure Container Apps rather than a one-off ACI container group' does not satisfy the mechanism that minimum determines warm capacity; maximum caps expansion under scaling triggers. The necessary action is 'Configure a supported HTTP scaling rule with minReplicas=0 and a tested maxReplicas sized for daytime peaks, then monitor scale behavior', which should be checked against this Azure resource's actual permissions and state.

Setting a minimum of one always-running replica can reduce cold starts for workloads that require immediate readiness, but it prevents the explicit scale-to-zero behavior in this scenario. Azure Container Apps supports a minimum of zero replicas for suitable HTTP and event-driven scaling configurations. With minReplicas at least one, the app would retain usage at night even when there are no inbound requests. Choose a supported HTTP rule and minReplicas=0 with a measured maximum for daytime peaks; evaluate any cold-start impact as a separate tradeoff rather than silently overriding the owner's zero-idle objective.

'Compare observed replica counts, load, errors and request latency against the trigger' solves another task because a configuration deployment does not establish that scaling is occurring or that capacity suffices. For the situation where a Container Apps endpoint has large traffic spikes but can scale down overnight, this distractor misses the requirement that minimum determines warm capacity; maximum caps expansion under scaling triggers. Unlike 'Compare observed replica counts, load, errors and request latency against the trigger', 'Configure a supported HTTP scaling rule with minReplicas=0 and a tested maxReplicas sized for daytime peaks, then monitor scale behavior' directly targets that requirement; its success must be confirmed at the authorized resource scope.

'Configure an authenticated event-driven Container Apps scale rule for the queue' applies to a different feature boundary because kEDA-backed rules can scale replicas using queue metrics without polling from the application itself. In the stated scenario where a container repeatedly restarts under sustained memory pressure, 'Configure an authenticated event-driven Container Apps scale rule for the queue' does not satisfy the mechanism that adding replicas may help load distribution but cannot repair a single container whose memory limit is too low. The necessary action is 'Review per-container memory/CPU limits and actual out-of-memory or probe events', which should be checked against this Azure resource's actual permissions and state.

The nearby action 'Evaluate Container Apps replica scaling versus fixed ACI group sizing' is associated with this separate need: a team proposes a single large ACI container for intermittent unpredictable HTTP demand rather than using managed autoscaling. That is because ACI sizes a container group; Container Apps can add replicas based on configured triggers. Here a container repeatedly restarts under sustained memory pressure, so 'Evaluate Container Apps replica scaling versus fixed ACI group sizing' misses the fact that adding replicas may help load distribution but cannot repair a single container whose memory limit is too low. 'Review per-container memory/CPU limits and actual out-of-memory or probe events' is the more defensible action; confirm its behavior in the target service before calling the task complete.

When a Container Apps endpoint has large traffic spikes but can scale down overnight, the action 'Choose tested minReplicas and maxReplicas limits aligned with latency and cost goals' can be relevant: minimum determines warm capacity; maximum caps expansion under scaling triggers. For the different problem of a container repeatedly restarts under sustained memory pressure, 'Choose tested minReplicas and maxReplicas limits aligned with latency and cost goals' misses the mechanism that adding replicas may help load distribution but cannot repair a single container whose memory limit is too low. Choosing 'Choose tested minReplicas and maxReplicas limits aligned with latency and cost goals' would address that other need, whereas 'Review per-container memory/CPU limits and actual out-of-memory or probe events' is intended to solve the stated condition.

'Compare observed replica counts, load, errors and request latency against the trigger' solves another task because a configuration deployment does not establish that scaling is occurring or that capacity suffices. For the situation where a worker should start when Service Bus queue depth grows and idle when messages are absent, this distractor misses the requirement that kEDA-backed rules can scale replicas using queue metrics without polling from the application itself. Unlike 'Compare observed replica counts, load, errors and request latency against the trigger', 'Configure an authenticated event-driven Container Apps scale rule for the queue' directly targets that requirement; its success must be confirmed at the authorized resource scope.

When a team proposes a single large ACI container for intermittent unpredictable HTTP demand rather than using managed autoscaling, the action 'Evaluate Container Apps replica scaling versus fixed ACI group sizing' can be relevant: ACI sizes a container group; Container Apps can add replicas based on configured triggers. For the different problem of a worker should start when Service Bus queue depth grows and idle when messages are absent, 'Evaluate Container Apps replica scaling versus fixed ACI group sizing' misses the mechanism that kEDA-backed rules can scale replicas using queue metrics without polling from the application itself. Choosing 'Evaluate Container Apps replica scaling versus fixed ACI group sizing' would address that other need, whereas 'Configure an authenticated event-driven Container Apps scale rule for the queue' is intended to solve the stated condition.

'Use Azure Container Apps rather than a one-off ACI container group' applies to a different feature boundary because container Apps supports managed ingress, revisions and scaling rules for service workloads. In the stated scenario where a worker should start when Service Bus queue depth grows and idle when messages are absent, 'Use Azure Container Apps rather than a one-off ACI container group' does not satisfy the mechanism that kEDA-backed rules can scale replicas using queue metrics without polling from the application itself. The necessary action is 'Configure an authenticated event-driven Container Apps scale rule for the queue', which should be checked against this Azure resource's actual permissions and state.

The nearby action 'Choose tested minReplicas and maxReplicas limits aligned with latency and cost goals' is associated with this separate need: a Container Apps endpoint has large traffic spikes but can scale down overnight. That is because minimum determines warm capacity; maximum caps expansion under scaling triggers. Here a worker should start when Service Bus queue depth grows and idle when messages are absent, so 'Choose tested minReplicas and maxReplicas limits aligned with latency and cost goals' misses the fact that kEDA-backed rules can scale replicas using queue metrics without polling from the application itself. 'Configure an authenticated event-driven Container Apps scale rule for the queue' is the more defensible action; confirm its behavior in the target service before calling the task complete.

'Configure an authenticated event-driven Container Apps scale rule for the queue' solves another task because kEDA-backed rules can scale replicas using queue metrics without polling from the application itself. For the situation where a payment API must have an immediately ready endpoint at all times. A proposal sets zero minimum replicas, this distractor misses the requirement that scale-to-zero can introduce startup delay; the stated availability contract requires warm instances. Unlike 'Configure an authenticated event-driven Container Apps scale rule for the queue', 'Set a minimum of at least one suitable running replica for always-ready capacity' directly targets that requirement; its success must be confirmed at the authorized resource scope.

When an application config change creates a new Container Apps revision, but the operator interprets it as an additional replica, the action 'Treat a revision as an immutable app version and replicas as running instances' can be relevant: revision versioning and autoscale replica count describe different axes of deployment. For the different problem of a payment API must have an immediately ready endpoint at all times. A proposal sets zero minimum replicas, 'Treat a revision as an immutable app version and replicas as running instances' misses the mechanism that scale-to-zero can introduce startup delay; the stated availability contract requires warm instances. Choosing 'Treat a revision as an immutable app version and replicas as running instances' would address that other need, whereas 'Set a minimum of at least one suitable running replica for always-ready capacity' is intended to solve the stated condition.

Increasing the upper replica ceiling allows more capacity after demand is detected, but it does not keep an endpoint ready while demand is absent. A zero minimum permits scale-to-zero, so the first incoming request may need to activate a container before the application serves traffic. This payment API explicitly requires an immediately ready endpoint at all times. Set and validate a nonzero minimum replica count appropriate to startup and capacity, and test the live readiness path instead of treating a higher maximum as an always-on guarantee.

When a managed HTTP microservice needs revision rollouts and traffic splitting, with event-driven scale, the action 'Use Azure Container Apps rather than a one-off ACI container group' can be relevant: container Apps supports managed ingress, revisions and scaling rules for service workloads. For the different problem of a new Container Apps scaling rule is deployed, but clients still see high latency, 'Use Azure Container Apps rather than a one-off ACI container group' misses the mechanism that a configuration deployment does not establish that scaling is occurring or that capacity suffices. Choosing 'Use Azure Container Apps rather than a one-off ACI container group' would address that other need, whereas 'Compare observed replica counts, load, errors and request latency against the trigger' is intended to solve the stated condition.

The nearby action 'Choose tested minReplicas and maxReplicas limits aligned with latency and cost goals' is associated with this separate need: a Container Apps endpoint has large traffic spikes but can scale down overnight. That is because minimum determines warm capacity; maximum caps expansion under scaling triggers. Here a new Container Apps scaling rule is deployed, but clients still see high latency, so 'Choose tested minReplicas and maxReplicas limits aligned with latency and cost goals' misses the fact that a configuration deployment does not establish that scaling is occurring or that capacity suffices. 'Compare observed replica counts, load, errors and request latency against the trigger' is the more defensible action; confirm its behavior in the target service before calling the task complete.

'Evaluate Container Apps replica scaling versus fixed ACI group sizing' solves another task because ACI sizes a container group; Container Apps can add replicas based on configured triggers. For the situation where a new Container Apps scaling rule is deployed, but clients still see high latency, this distractor misses the requirement that a configuration deployment does not establish that scaling is occurring or that capacity suffices. Unlike 'Evaluate Container Apps replica scaling versus fixed ACI group sizing', 'Compare observed replica counts, load, errors and request latency against the trigger' directly targets that requirement; its success must be confirmed at the authorized resource scope.

'Recognize that the App Service plan provisions shared compute capacity for its apps' applies to a different feature boundary because plan CPU/memory and instance count can affect all apps sharing the same plan. In the stated scenario where a web application needs deployment slots and platform autoscaling not available in its current basic plan, 'Recognize that the App Service plan provisions shared compute capacity for its apps' does not satisfy the mechanism that plan capabilities vary by tier; raising the app runtime version does not add plan entitlements. The necessary action is 'Choose a supported App Service plan tier offering required slots and scale features', which should be checked against this Azure resource's actual permissions and state.

'Use an eligible App Service backup-capable tier and configure destination/policy' solves another task because backup support is tier- and configuration-dependent; do not confuse it with Azure VM backup. For the situation where a web application needs deployment slots and platform autoscaling not available in its current basic plan, this distractor misses the requirement that plan capabilities vary by tier; raising the app runtime version does not add plan entitlements. Unlike 'Use an eligible App Service backup-capable tier and configure destination/policy', 'Choose a supported App Service plan tier offering required slots and scale features' directly targets that requirement; its success must be confirmed at the authorized resource scope.

Scaling out adds running workers within the capabilities of the same pricing tier. It does not promote a Basic App Service plan into a tier that supports deployment slots. The question explicitly requires slots and appropriate autoscaling features, so merely increasing an instance count without changing tier leaves that requirement unsatisfied. Choose a plan tier that offers the required features, then check slot and scale limits before moving the app. Validate that any existing app or shared plan dependencies are compatible with the tier change rather than inferring feature availability from worker count.

'Separate compute plans or size shared plan capacity after measured isolation/cost review' applies to a different feature boundary because sharing a plan saves cost but shares worker resources and scaling behavior. In the stated scenario where a web application needs deployment slots and platform autoscaling not available in its current basic plan, 'Separate compute plans or size shared plan capacity after measured isolation/cost review' does not satisfy the mechanism that plan capabilities vary by tier; raising the app runtime version does not add plan entitlements. The necessary action is 'Choose a supported App Service plan tier offering required slots and scale features', which should be checked against this Azure resource's actual permissions and state.

The nearby action 'Use scale-up to change worker SKU and scale-out to change instance count' is associated with this separate need: a developer increases App Service plan size but calls it instance scale-out. That is because vertical and horizontal scaling solve different capacity limits and may have different costs. Here several web apps share one App Service plan, and operators believe each app owns separate dedicated worker VMs, so 'Use scale-up to change worker SKU and scale-out to change instance count' misses the fact that plan CPU/memory and instance count can affect all apps sharing the same plan. 'Recognize that the App Service plan provisions shared compute capacity for its apps' is the more defensible action; confirm its behavior in the target service before calling the task complete.

Apps assigned to the same App Service plan share the worker-instance capacity provisioned for that plan, subject to platform and plan behavior. The mere presence of separate app names does not create dedicated VMs or independent compute allocations. If contention is a concern, measure plan usage and decide whether to move selected apps into separate supported plans. Assuming independent workers can hide the actual resource-sharing bottleneck.

When a web application needs deployment slots and platform autoscaling not available in its current basic plan, the action 'Choose a supported App Service plan tier offering required slots and scale features' can be relevant: plan capabilities vary by tier; raising the app runtime version does not add plan entitlements. For the different problem of several web apps share one App Service plan, and operators believe each app owns separate dedicated worker VMs, 'Choose a supported App Service plan tier offering required slots and scale features' misses the mechanism that plan CPU/memory and instance count can affect all apps sharing the same plan. Choosing 'Choose a supported App Service plan tier offering required slots and scale features' would address that other need, whereas 'Recognize that the App Service plan provisions shared compute capacity for its apps' is intended to solve the stated condition.

When two busy apps share one plan, and one app starves the other during traffic peaks, the action 'Separate compute plans or size shared plan capacity after measured isolation/cost review' can be relevant: sharing a plan saves cost but shares worker resources and scaling behavior. For the different problem of a Linux web app is added to an existing Windows App Service plan in a different region, 'Separate compute plans or size shared plan capacity after measured isolation/cost review' misses the mechanism that apps on a plan must satisfy the plan's platform and region constraints. Choosing 'Separate compute plans or size shared plan capacity after measured isolation/cost review' would address that other need, whereas 'Use a compatible operating-system and regional App Service plan' is intended to solve the stated condition.

'Use supported App Service backup/restore capabilities rather than VM disk backup' applies to a different feature boundary because App Service does not give the tenant an ordinary VM disk to protect with VM Recovery Services policy. In the stated scenario where a Linux web app is added to an existing Windows App Service plan in a different region, 'Use supported App Service backup/restore capabilities rather than VM disk backup' does not satisfy the mechanism that apps on a plan must satisfy the plan's platform and region constraints. The necessary action is 'Use a compatible operating-system and regional App Service plan', which should be checked against this Azure resource's actual permissions and state.

The nearby action 'Check plan-tier instance limits and move to a supported tier if justified' is associated with this separate need: an App Service application cannot scale to the requested number of instances on its current tier. That is because autoscale rules cannot bypass platform limits of the selected compute plan. Here a Linux web app is added to an existing Windows App Service plan in a different region, so 'Check plan-tier instance limits and move to a supported tier if justified' misses the fact that apps on a plan must satisfy the plan's platform and region constraints. 'Use a compatible operating-system and regional App Service plan' is the more defensible action; confirm its behavior in the target service before calling the task complete.

A higher pricing tier can change the capabilities and available worker sizes of an App Service plan, but it does not inherently allocate a separate set of workers to one of two apps that remain within the same plan. The stated requirement is not simply more CPU or a feature such as deployment slots; it is insulation of App B from App A's bursts and independent scaling. Leaving both apps on the shared plan preserves their worker contention, so an approved separate App Service plan is the direct isolation change.

Scaling up increases the shared worker size and scaling out adds shared worker instances, which can reduce resource pressure in some workloads. However, Microsoft documents that apps in the same App Service plan share worker compute and normally scale with the plan. This case explicitly rejects extra shared capacity as a substitute for an independent compute boundary. Because App A can still compete for the same workers after scaling, the action does not establish the required per-app resource isolation. Use a separate plan for App B if independent workers and scaling are mandatory.

App Service plans have operating system and region compatibility requirements, so an engineer should validate those when creating or moving an app. Merely changing an operating-system selection on the existing shared plan, though, is not a way to isolate two web apps' CPU consumption; it may also be unsupported for existing plans. The contention arises from their placement on shared worker instances. The scenario requires different compute allocations and scaling boundaries, which are obtained by moving App B to a compatible separate plan, not by an OS-only change.

Identifying that App Service apps in one plan share workers accurately describes the root cause, but it is a diagnosis rather than the requested architecture. If App B remains on the existing shared workers, App A's bursts can still consume CPU and memory that App B needs. The requirement is for independent compute resources and scaling decisions, not for an explanation of the current limitation. After confirming resource and region compatibility, assign App B to a distinct App Service plan and validate that its worker scaling is independent.

'Recognize that the App Service plan provisions shared compute capacity for its apps' applies to a different feature boundary because plan CPU/memory and instance count can affect all apps sharing the same plan. In the stated scenario where a developer increases App Service plan size but calls it instance scale-out, 'Recognize that the App Service plan provisions shared compute capacity for its apps' does not satisfy the mechanism that vertical and horizontal scaling solve different capacity limits and may have different costs. The necessary action is 'Use scale-up to change worker SKU and scale-out to change instance count', which should be checked against this Azure resource's actual permissions and state.

The nearby action 'Check plan-tier instance limits and move to a supported tier if justified' is associated with this separate need: an App Service application cannot scale to the requested number of instances on its current tier. That is because autoscale rules cannot bypass platform limits of the selected compute plan. Here a developer increases App Service plan size but calls it instance scale-out, so 'Check plan-tier instance limits and move to a supported tier if justified' misses the fact that vertical and horizontal scaling solve different capacity limits and may have different costs. 'Use scale-up to change worker SKU and scale-out to change instance count' is the more defensible action; confirm its behavior in the target service before calling the task complete.

When a Linux web app is added to an existing Windows App Service plan in a different region, the action 'Use a compatible operating-system and regional App Service plan' can be relevant: apps on a plan must satisfy the plan's platform and region constraints. For the different problem of a developer increases App Service plan size but calls it instance scale-out, 'Use a compatible operating-system and regional App Service plan' misses the mechanism that vertical and horizontal scaling solve different capacity limits and may have different costs. Choosing 'Use a compatible operating-system and regional App Service plan' would address that other need, whereas 'Use scale-up to change worker SKU and scale-out to change instance count' is intended to solve the stated condition.