AI-200 practice: Build serverless APIs, including implementing triggers and bindings

Question 1

You write an Azure Function using the Python v2 programming model, triggered by an HTTP request, that should also write a message to a Storage Queue as an output binding:
```python
import azure.functions as func

app = func.FunctionApp()

@app.route(route="submit", auth_level=func.AuthLevel.FUNCTION)
@app.queue_output(arg_name="msg", queue_name="orders-queue", connection="AzureWebJobsStorage")
def submit_order(req: func.HttpRequest, msg: func.Out[str]) -> func.HttpResponse:
    order_id = req.params.get("orderId")
    msg.set(order_id)
    return func.HttpResponse(f"Order {order_id} submitted", status_code=200)
```
Deploying this function, HTTP requests succeed and return 200, but no messages ever appear in orders-queue. What is the most likely cause?

Accepted Answer

AzureWebJobsStorage does not point to the same storage account as orders-queue, or the queue name/casing doesn't match an existing queue.

Answer

The decorator order matters: @app.route must be the innermost decorator and @app.queue_output the outermost.

Answer

func.Out[str] is invalid; queue output bindings require func.Out[bytes].

Answer

auth_level=func.AuthLevel.FUNCTION blocks all output bindings from executing.

Question 2

You configure a Cosmos DB trigger function to process change feed events, and need it to use Managed Identity instead of a connection string:
```json
// function.json (or equivalent binding in Python v2 model)
{
  "type": "cosmosDBTrigger",
  "connectionStringSetting": "CosmosDBConnection",
  "databaseName": "ragdb",
  "collectionName": "chunks",
  "leaseCollectionName": "leases"
}
```
To use Managed Identity authentication instead of a connection string, which changes are required?

Accepted Answer

Replace connectionStringSetting with a connection property pointing to an app setting prefix (e.g., "connection": "CosmosDBConnection") where CosmosDBConnection__accountEndpoint is set to the Cosmos DB account URI (no key), and assign the Function App's managed identity the appropriate Cosmos DB RBAC role (e.g., Cosmos DB Built-in Data Contributor) on the account.

Answer

Managed Identity is not supported for Cosmos DB trigger bindings; a connection string is always required.

Answer

Add "authType": "ManagedIdentity" directly to the binding JSON; no app settings changes are needed.

Answer

Use DefaultAzureCredential inside the function body to authenticate; the binding's connectionStringSetting can remain a placeholder value.

Question 3

You implement retry logic for a transient-failure-prone HTTP-triggered function calling an external API, using the Python v2 model's built-in retry policy:
```python
@app.function_name(name="CallExternalApi")
@app.route(route="call-api")
@app.retry(strategy="fixed_delay", max_retry_count=3, delay_interval="00:00:05")
def call_external_api(req: func.HttpRequest) -> func.HttpResponse:
    response = requests.get("https://partner-api.example.com/data")
    response.raise_for_status()
    return func.HttpResponse(response.text)
```
The retry policy has no effect — the function still fails immediately on the first raise_for_status() exception without retrying. What is the issue?

Accepted Answer

Function-level retry policies (@app.retry) apply only to specific trigger types that support the Functions runtime's built-in retry mechanism — such as Timer, Queue, Event Hub, Service Bus, and Cosmos DB triggers — not to HTTP triggers, since an HTTP trigger's contract is a synchronous request/response.

Answer

strategy="fixed_delay" is invalid; only "exponential_backoff" is a supported retry strategy.

Answer

max_retry_count=3 is too low; retries only activate above 5.

Answer

delay_interval must be specified in seconds as an integer (5), not as a timespan string.

Question 4

You tune host.json for a high-throughput Event Hub-triggered function processing telemetry data, aiming to maximize batch processing efficiency:
```json
{
  "version": "2.0",
  "extensions": {
    "eventHubs": {
      "batchCheckpointFrequency": 1,
      "eventProcessorOptions": {
        "maxBatchSize": 10,
        "prefetchCount": 20
      }
    }
  }
}
```
Given the goal of maximizing throughput for a high-volume stream, and knowing checkpointing after every single batch adds storage overhead, which change best improves throughput while maintaining reasonable fault-tolerance?

Accepted Answer

Increase maxBatchSize substantially (e.g., to 256 or higher, matched to available memory and processing capacity) to process more events per function invocation, and increase batchCheckpointFrequency (e.g., to 5) so checkpoints are written less often — after every N batches rather than every single batch — reducing checkpoint storage overhead while keeping failure reprocessing bounded.

Answer

Set batchCheckpointFrequency to 0 to disable checkpointing entirely.

Answer

Decrease maxBatchSize to 1 so each event is processed individually.

Answer

Remove prefetchCount entirely; prefetching always reduces throughput.

Question 5

Which Azure Functions trigger type causes a function to execute automatically whenever a new message arrives in a Service Bus queue?

Accepted Answer

Service Bus trigger

Answer

HTTP request trigger

Answer

Timer schedule trigger

Answer

Blob storage trigger

Question 6

An Azure Function with an HTTP trigger calls Azure OpenAI to generate embeddings, but occasionally times out under high load because the default HTTP trigger timeout is exceeded. What is the most appropriate architectural fix?

Accepted Answer

Queue the work; process async; client polls status

Answer

Set unlimited HTTP timeout on the Consumption plan

Answer

Tighten sync OpenAI retries without changing pattern

Answer

Change function language from Python to C# only

Question 7

Which Azure Functions binding type allows a function to write output directly to a Cosmos DB container without manually instantiating a CosmosClient?

Accepted Answer

Cosmos DB output binding in function.json/attributes

Answer

HTTP trigger with a hand-written REST Cosmos call

Answer

Queue trigger configured with no Cosmos binding

Answer

App Configuration binding writing to Cosmos DB

Question 8

Your Azure Function needs to both trigger on new blobs and write processed results back to a different container, entirely through declarative bindings rather than manual SDK calls. Which binding types should you use together?

Accepted Answer

Blob trigger for input and Blob output for results

Answer

HTTP trigger for input and Timer binding for output

Answer

Cosmos trigger for input and Event Grid for output

Answer

Service Bus trigger alone with no output binding

Question 9

Which Azure Functions binding direction should be used if a function needs to send a new message onto a Service Bus queue as part of its execution, without manually creating a ServiceBusClient?

Accepted Answer

Output binding targeting the Service Bus queue

Answer

Input binding on the same queue as the trigger

Answer

Trigger binding with direction incorrectly set out

Answer

No binding; always require a manual SDK client

Question 10

You are configuring an Azure Function to process images uploaded to a Blob container and generate descriptions using a vision model. Which binding configuration parameter is most efficient to minimize memory overhead when handling large images in Python?

Accepted Answer

dataType: stream

Answer

dataType: binary

Answer

dataType: string

Answer

dataType: base64

12 questions