Tüm alıştırma soruları

You have a Standard General Purpose v2 (GPv2) storage account. You need to implement an Azure Blob Storage lifecycle management policy to automatically move block blobs to the Cool tier after $30$ days have elapsed since their last modification.

Which of the following JSON fragments contains the correct action and property names to achieve this?

You are developing a data processing solution using Azure Durable Functions. You need to sequence the execution flow of the application during a standard function chaining scenario. Arrange the actions in the correct chronological order from start to finish.

You are a developer configuring an Azure App Service web app to connect to an on-premises Microsoft SQL Server database on port $1433$. You must use Azure Hybrid Connections to establish the connection without opening public inbound firewall ports on the local network.

Arrange the steps in the correct order to configure and establish the Hybrid Connection.

An agricultural technology system uses an Azure Cosmos DB Core (SQL) API container to store telemetry data from $10,000$ active IoT soil sensors. The system has the following workload characteristics:

- Sensor telemetry is ingested continuously with high-throughput writes.
- Queries frequently retrieve the telemetry history for a specific sensor over a single day to display daily graphs.
- The container uses stored procedures to perform atomic batch transactions that update daily average readings, requiring all telemetry items for a specific sensor on a specific day to reside in the same logical partition.
- Using either the sensor identifier (`SensorId`) or the date (`ReadingDate`) alone as the partition key would lead to hot partitions.

Which partition key strategy should you implement to satisfy these requirements while optimizing throughput and avoiding hot partitions?

A development team is configuring an Azure Function App (V4 runtime) to connect to a SQL database. The database connection string must be stored securely in Azure Key Vault. The security architecture mandates that the Function App must retrieve the connection string at runtime using a system-assigned managed identity, without storing any credentials in the application's configuration settings.

Which of the following configuration flows must be implemented to ensure the Function App can successfully retrieve the connection string?

You host a web application on an Azure App Service Web App that currently runs on the Free (F1) App Service plan. You need to configure the web app to automatically scale out when the CPU utilization exceeds $80\%$. In which order should you perform the configuration steps?

A company plans to host a web API in Azure Container Instances (ACI). The Docker image for the API is stored in a private Azure Container Registry (ACR). At startup, the API container must download a database connection string from Azure Key Vault. To maintain high security, the solution must meet these criteria: Avoid storing cleartext registry credentials in the ACI deployment template; Authenticate to the private ACR to download the image; Retrieve the connection string from Key Vault without embedding credentials in the application code. Which identity and authentication configuration should be implemented to support this deployment?

An organization deploys an Azure Function App (V4 runtime) on a Consumption plan. The function is triggered by an Azure Storage queue and processes incoming orders by writing them to an on-premises database via a Hybrid Connection. During peak hours, rapid scale-out of the Function App causes too many concurrent database connections, exceeding the database's connection limit. You need to restrict the maximum number of concurrent function app instances to 5 to protect the database, without changing the hosting plan or modifying the function code. Which configuration change should you implement?

You are developing a compliance audit workflow for a legal technology firm using Azure Durable Functions in C# (.NET Isolated process). You write the following orchestrator function to verify a batch of documents against a policy:

csharp
[Function("ComplianceAuditOrchestrator")]
public static async Task<string> Run(
[OrchestrationTrigger] TaskOrchestrationContext context)
{
var request = context.GetInput<AuditRequest>();

using (var client = new HttpClient())
{
var response = await client.GetAsync($"https://api.legalcorp.com/rules/{request.PolicyId}");
if (!response.IsSuccessStatusCode)
{
throw new Exception("Failed to retrieve policy rules.");
}
}

var tasks = new List<Task<bool>>();
foreach (var doc in request.Documents)
{
tasks.Add(context.CallActivityAsync<bool>("ScanDocumentActivity", doc));
}

var results = await Task.WhenAll(tasks);
return results.All(r => r) ? "Passed" : "Failed";
}

During testing in a high-volume staging environment, you notice that the orchestrator behaves non-deterministically, occasionally fails with orchestrator validation errors, and performs redundant HTTP calls to the external policy API.

Which modification should you apply to resolve these issues and ensure the orchestrator is deterministic?

Match each Azure Cosmos DB consistency level on the left with its corresponding behavior or guarantee on the right.

To secure database credentials, a company's web application running on an Azure App Service web app must load its connection string from a central Azure Key Vault. The developers plan to configure Key Vault references within the app settings.

Which two configuration steps are required to ensure the web app can successfully resolve the references at runtime? (Choose two.)

A healthcare organization is designing an Azure Cosmos DB Core (SQL) API container to store real-time telemetry from $100,000$ active medical wearables. The system ingests approximately $20,000$ write operations per second, with each document containing the fields `deviceId`, `patientId`, `timestamp` (ISO 8601 string format), `hospitalId`, and `vitalMetrics`.

The container must satisfy the following requirements:
- Ingestion & Storage: Prevent hot partitions. While overall writes are balanced, intensive care patients generate $10\times$ more telemetry packets than standard patients.
- Queries: Optimize read queries from clinicians retrieving a patient's telemetry for a single day (e.g., `SELECT * FROM c WHERE c.patientId = 'P-8802' AND c.timestamp STARTSWITH '2026-07-16'`).
- Transactional Scope: Stored procedures must execute transactional batches to atomically update a patient's daily summary document alongside new telemetry entries.

Which two design decisions should you implement to satisfy these requirements? (Select two.)

You are designing an Azure Cosmos DB Core (SQL) API solution for a smart city traffic management platform. The platform collects real-time vehicle telemetry from $10,000$ traffic sensors deployed across $5$ major cities.

Workload Profiles:
- Write Ingestion: Highly write-heavy. Each sensor transmits telemetry (including `sensorId`, `cityName`, `timestamp` in `YYYY-MM-DD hh:mm:ss` format, and `vehicleCount`) every $10$ seconds. Write volume peaks heavily during rush hours.
- Read Queries: Real-time traffic control dashboards query the most recent $5$ minutes of telemetry data for a specific city to adjust traffic light timings (high-frequency, low-latency reads).
- Transactional Boundary: A stored procedure must run atomically to update both the daily aggregate vehicle count and the latest telemetry record for a specific sensor.

You need to select the partitioning strategy that avoids the hot partition problem for writes, satisfies the transactional requirements, and minimizes Request Unit (RU) consumption for read queries.

Which two strategies should you implement? (Select two.)

You are designing an Azure Cosmos DB Core (SQL) API container for a logistics monitoring system that tracks delivery fleet telemetry. The system receives data from $50,000$ active vehicles. Each vehicle is assigned to one of $20$ shipping carriers.

The telemetry documents contain the following fields:
- `vehicleId` (unique string identifier)
- `carrierId` (unique carrier code)
- `routeId` (unique route identifier)
- `timestamp` (date and time of the reading)
- `location` (latitude/longitude coordinates)

The system has the following requirements:
- Writes: Telemetry is ingested continuously at a rate of $5,000$ writes per second. Three large shipping carriers account for $85\%$ of all vehicle updates.
- Reads: Active tracking dashboards query vehicle locations for a specific route. These queries always filter by `routeId` and `timestamp`.
- Transactions: When a vehicle crosses a state line, the platform must execute a transactional batch operation to atomically update the vehicle status and insert a route checkpoint log.

Which partition key strategy should you select to meet these requirements while preventing hot partitions and optimizing query performance?

A development team is deploying a containerized microservice to Azure Container Instances (ACI). The containerized microservice must securely connect to a database hosted in an Azure Virtual Network (VNet) without exposing the database to the public internet. The microservice uses a custom Linux-based container image. Which configuration is required to successfully deploy the container group into the Azure Virtual Network?

An organization hosts a web application on an Azure App Service plan that is currently configured for the Basic (B1) pricing tier. You are tasked with configuring the web app to automatically scale out (autoscale) whenever the average CPU usage exceeds $75\%$.

What must you do first?

You are developing an Azure Function App (V4 runtime) that processes messages from an Azure Storage Queue. The processing logic for some messages can take up to 15 minutes to complete. The security policy requires that the Queue connection string must be stored securely in Azure Key Vault and must not be exposed in the application source code or settings files.

Which two configurations or actions should you implement to meet these requirements? (Select TWO.)

You are developing a serverless workflow using Azure Durable Functions. You need to ensure that the orchestrator function remains deterministic during execution. Which two actions must you perform to meet this requirement?

A company hosts a financial processing API on an Azure App Service Web App that currently runs on the Standard (S1) pricing tier with a default instance count of 2. During peak hours, the API experiences high CPU utilization. You are configuring Azure Monitor autoscale rules to handle this load. You create a scale-out rule that increases the instance count by 1 when the average CPU Percentage is greater than 80% for 10 minutes. To prevent autoscale flapping (rapidly alternating between scaling out and scaling in), which of the following scale-in configurations should you implement?

You are developing an Azure Function App (V4 runtime) that contains a Service Bus triggered function. The function is configured with a connection property named `TelemetryServiceBus`.

Your company's security policy prohibits the use of secrets or connection strings in application settings. You must configure the Function App to connect to the Azure Service Bus namespace using a user-assigned managed identity that has the client ID `11111111-2222-3333-4444-555555555555`.

Which three application settings must you add to the Function App's configuration to establish this identity-based connection?