Tüm alıştırma soruları

An organization is migrating an existing Azure Function App (V4 runtime) to meet security compliance guidelines that forbid storing connection strings in application settings. You must configure the Function App to use an identity-based connection for its default host storage account ($AzureWebJobsStorage$) using a system-assigned managed identity.

Which of the following actions must you perform? (Select TWO)

You are configuring deployment slots for an Azure App Service web app named app-payment-service. The application requires specific configurations in the staging slot to run integration tests before being swapped into the production slot. You need to identify which configuration settings will be transferred to the production slot and which will remain slot-specific during the swap operation. Which two of the following settings are swapped by default when you perform a slot swap?

An organization is designing an Azure Cosmos DB container to store employee profile documents. The system must support high-volume write operations and maintain efficient query performance.

Which two statements describe correct characteristics of Azure Cosmos DB partitioning that must be considered?

You are deploying a containerized application to Azure Container Apps. The container image is hosted in a private Azure Container Registry (ACR) named myregistry.azurecr.io. You have created a user-assigned managed identity named identity-aca in the resource group rg-prod, and the identity has already been granted the AcrPull role on the registry. You need to configure an existing Container App named api-service in the same resource group to use this user-assigned managed identity to authenticate and pull the image from the registry. Which two of the following Azure CLI commands should you run to complete the configuration? (Select TWO.)

You are developing a secure containerized application that will run in Azure Container Instances (ACI). The container needs to read a database connection string from an Azure Key Vault at startup. To follow security best practices, the container group must authenticate to the Key Vault without storing any credentials in the deployment template or container image. Additionally, the identity's lifecycle must be tied directly to the lifecycle of the container group, meaning the identity is automatically deleted when the container group is deleted. Which identity configuration should you apply to the container group?

You are designing an Azure Cosmos DB container for a smart home energy monitoring platform that receives real-time telemetry from $50,000$ active devices. The workload has the following characteristics:

* Write profile: High-volume write ingestion of hourly usage metrics ($10,000$ writes/sec).
* Read profile: Frequent read queries searching for telemetry by device ID and a specific date range.
* Transactional boundary: The platform must run ACID transactions using transactional batches to calculate and update daily summary aggregates for a device on a specific day.
* Storage profile: Individual devices generate a high volume of data that must be retained indefinitely.

You need to configure the partitioning strategy to support the transactional requirements, avoid the hot partition problem, and prevent logical partitions from exceeding the $20\text{ GB}$ limit.

Which two strategies should you implement?

You are designing a financial reconciliation pipeline using Azure Durable Functions in C#. The workflow is triggered hourly to audit transactions. A critical activity function in the pipeline performs a complex ledger analysis that takes up to 25 minutes to execute. Additionally, the orchestrator function must generate a unique tracking identifier for each transaction and write a custom log entry to Azure Application Insights at the start of each execution.

You need to select the appropriate hosting plan and ensure the orchestrator function complies with the Durable Functions execution constraints.

Which two actions should you perform? (Select two.)

You are developing a new event-driven Azure Function that will process messages from an Azure Queue Storage queue. The message traffic is highly irregular with long periods of inactivity. To minimize costs, you require a hosting plan that scales to zero instances when idle and charges you only for the resources consumed during execution.

Which hosting plan should you select?

You are deploying a web application to an Azure App Service web app named app-inventory. The application must retrieve a database connection string from an Azure Key Vault named kv-prod.

You have the following requirements:
- Authenticate to the Key Vault using a user-assigned managed identity named id-inventory.
- Configure the application settings of the web app to retrieve the credential using a Key Vault reference.
- Ensure the configuration automatically retrieves the latest version of the secret.

Which two actions must you perform to configure the web app? (Choose two.)

You are designing a new Azure Function App (V4 runtime) to process messages from an Azure Service Bus queue. The function app must meet the following requirements:
- Connect to the queue using outbound virtual network integration.
- Support individual execution times that can last up to 25 minutes.
- Minimize cold starts by maintaining at least one pre-warmed instance at all times.
- Scale dynamically based on the queue length without manual scaling rule configuration.

Which hosting plan should you select for the Azure Function App?

A logistics tracking solution uses an Azure App Service Web App to process real-time GPS telemetry. The web app is currently hosted on the Free (F1) pricing tier. During morning dispatch hours, telemetry processing causes the memory usage to spike up to 85%, resulting in out-of-memory errors. You must configure the App Service plan and autoscale rules to dynamically scale out the web app when the Memory Percentage metric exceeds 80% for 10 minutes, while minimizing costs and preventing autoscale flapping.

Which two actions should you perform? (Select TWO)

You are deploying a containerized application to Azure Container Apps. The container image is hosted in a private Azure Container Registry (ACR). Which two methods can you use to configure the Container App to authenticate and pull the image from the private registry? (Select two.)

A developer needs to configure an Azure Container Registry (ACR) named `registry204` to notify an external service via a webhook whenever a new container image tag is pushed. The developer must also verify that the webhook is successfully triggered by a push event. Which sequence of steps should the developer perform?

A startup hosts a promotional website on an Azure App Service Web App that is currently running on the Shared ($D1$) pricing tier. The company expects a temporary increase in web traffic during an upcoming product launch and wants to scale out the application to multiple instances to distribute the load. What must you do first to enable scaling out for this App Service Web App?

An organization deploys a globally distributed web application using Azure Cosmos DB. The application has a requirement that when a manager updates a system setting in client session $A$, all other administrators using client session $B$ in other regions must immediately see the updated setting. The developer does not want to pass or share session tokens between these separate client sessions. Which consistency level should be selected to meet this requirement?

You are designing an Azure Function App to process background jobs. The system has the following constraints:

- A single execution of the function can take up to 25 minutes to complete.
- The function must securely connect to an Azure SQL Database located inside a private Azure Virtual Network (VNet).
- The Function App must scale out dynamically to handle unpredictable spikes in traffic.
- You must avoid cold start latency when new messages arrive while minimizing costs during low-traffic periods.

Which hosting plan should you choose for the Function App?

You are deploying a multi-container group to Azure Container Instances (ACI) using a YAML manifest. The application container needs to pull a private image from an Azure Container Registry (ACR) named `myregistry.azurecr.io`.

The manifest contains the following snippet:

yaml
identity:
type: SystemAssigned
imageRegistryCredentials:
- server: myregistry.azurecr.io
identity: system

When you run `az container create`, the deployment fails with an image pull authentication error.

Which configuration change must you implement in the YAML manifest to resolve the issue?

You are developing a nightly data aggregation pipeline using Azure Durable Functions (.NET Isolated process). The orchestrator function is triggered daily to collect sales reports from multiple regional API endpoints, consolidate them, and write the summary to a database.

The orchestrator code is defined as follows:

csharp
[Function("AggregateDailySalesOrchestrator")]
public static async Task<SalesSummary> Run(
[OrchestrationTrigger] TaskOrchestrationContext context)
{
var regions = await context.CallActivityAsync<List<string>>("GetActiveRegions", null);

var tasks = new List<Task<RegionReport>>();
foreach (var region in regions)
{
tasks.Add(context.CallActivityAsync<RegionReport>("FetchRegionReport", region));
}

// Fan-out: wait for all parallel fetch operations to complete
var reports = await Task.WhenAll(tasks);

// Fan-in processing
var summary = new SalesSummary { RunId = Guid.NewGuid().ToString() };
foreach (var report in reports)
{
if (report.Timestamp >= DateTime.UtcNow.AddHours(-24))
{
summary.TotalRevenue += report.Revenue;
}
}

await context.CallActivityAsync("SaveSummaryToDatabase", summary);
return summary;
}

During testing under heavy loads, you observe that the `FetchRegionReport` activity function occasionally takes up to $12$ minutes to complete due to slow external APIs, resulting in execution failures. The Function App is currently deployed to an Azure Functions Consumption plan.

Which action must you take to ensure that the orchestration runs successfully, executes without timeouts, and produces deterministic results?

A gaming company is developing an Azure Cosmos DB database to support a new multiplayer battle arena game. The workload has the following profiles:

- Write profile: Approximately $50,000$ writes per second during peak hours to update active match telemetry and state.
- Read profile: Low-latency point reads to fetch the active state of a specific match.
- Transactional boundary: Multiple documents within a single match—specifically the session state document and individual player statistics—must be updated atomically using a Transactional Batch.

The document properties include:
- `gameSessionId`: A unique GUID identifying each match (high cardinality, thousands of concurrent sessions).
- `playerId`: A unique GUID identifying each player (high cardinality).
- `region`: The geographic region of the game server (low cardinality, e.g., 'US-West', 'EU-Central').
- `sessionDate`: The date of the session (e.g., '2026-07-16').

Which partition key should you choose for the container?

A developer is configuring an Azure Cosmos DB account. The application requires that reads must never see out-of-order writes. However, the application can tolerate some replication lag and must not rely on client-managed session tokens. Which two consistency levels meet these requirements? (Select two)