Tip

If you plan to use the HTTP or WebHook bindings, plan to avoid port exhaustion that can be caused by improper instantiation ofHttpClient. For more information, seeHow to manage connections in Azure Functions.

Azure Functions supports two programming models for Python. The way that you define your bindings depends on your chosen programming model.

This article supports both programming models.

A C# function can be created by using one of the following C# modes:

• Isolated worker model: Compiled C# function that runs in a worker process that's isolated from the runtime. Isolated worker process is required to support C# functions running on LTS and non-LTS versions .NET and the .NET Framework. Extensions for isolated worker process functions useMicrosoft.Azure.Functions.Worker.Extensions.* namespaces.
• In-process model: Compiled C# function that runs in the same process as the Functions runtime. In a variation of this model, Functions can be run usingC# scripting, which is supported primarily for C# portal editing. Extensions for in-process functions useMicrosoft.Azure.WebJobs.Extensions.* namespaces.

The code in this article defaults to .NET Core syntax, used in Functions version 2.x and higher. For information on the 1.x syntax, see the1.x functions templates.

[Function("HttpFunction")]public IActionResult Run(    [HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequest req){    return new OkObjectResult($"Welcome to Azure Functions, {req.Query["name"]}!");}

[Function(nameof(HttpFunction))]public static HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestData req,    FunctionContext executionContext){    var logger = executionContext.GetLogger(nameof(HttpFunction));    logger.LogInformation("message logged");    var response = req.CreateResponse(HttpStatusCode.OK);    response.Headers.Add("Content-Type", "text/plain; charset=utf-8");    response.WriteString("Welcome to .NET isolated worker !!");    return response;}

[FunctionName("HttpTriggerCSharp")]public static async Task<IActionResult> Run(    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]    HttpRequest req, ILogger log){    log.LogInformation("C# HTTP trigger function processed a request.");    string name = req.Query["name"];    string requestBody = String.Empty;    using (StreamReader streamReader =  new  StreamReader(req.Body))    {        requestBody = await streamReader.ReadToEndAsync();    }    dynamic data = JsonConvert.DeserializeObject(requestBody);    name = name ?? data?.name;    return name != null        ? (ActionResult)new OkObjectResult($"Hello, {name}")        : new BadRequestObjectResult("Please pass a name on the query string or in the request body");}

This section contains the following examples:

• Read parameter from the query string
• Read body from a POST request
• Read parameter from a route
• Read POJO body from a POST request

The following examples show the HTTP trigger binding.

Read parameter from the query string

This example reads a parameter, namedid, from the query string, and uses it to build a JSON document returned to the client, with content typeapplication/json.

@FunctionName("TriggerStringGet")public HttpResponseMessage run(        @HttpTrigger(name = "req",             methods = {HttpMethod.GET},             authLevel = AuthorizationLevel.ANONYMOUS)        HttpRequestMessage<Optional<String>> request,        final ExecutionContext context) {    // Item list    context.getLogger().info("GET parameters are: " + request.getQueryParameters());    // Get named parameter    String id = request.getQueryParameters().getOrDefault("id", "");    // Convert and display    if (id.isEmpty()) {        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)                        .body("Document not found.")                        .build();    }     else {        // return JSON from to the client        // Generate document        final String name = "fake_name";        final String jsonDocument = "{\"id\":\"" + id + "\", " +                                         "\"description\": \"" + name + "\"}";        return request.createResponseBuilder(HttpStatus.OK)                        .header("Content-Type", "application/json")                        .body(jsonDocument)                        .build();    }}

Read body from a POST request

This example reads the body of a POST request, as aString, and uses it to build a JSON document returned to the client, with content typeapplication/json.

    @FunctionName("TriggerStringPost")    public HttpResponseMessage run(            @HttpTrigger(name = "req",               methods = {HttpMethod.POST},               authLevel = AuthorizationLevel.ANONYMOUS)            HttpRequestMessage<Optional<String>> request,            final ExecutionContext context) {        // Item list        context.getLogger().info("Request body is: " + request.getBody().orElse(""));        // Check request body        if (!request.getBody().isPresent()) {            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)                          .body("Document not found.")                          .build();        }         else {            // return JSON from to the client            // Generate document            final String body = request.getBody().get();            final String jsonDocument = "{\"id\":\"123456\", " +                                          "\"description\": \"" + body + "\"}";            return request.createResponseBuilder(HttpStatus.OK)                          .header("Content-Type", "application/json")                          .body(jsonDocument)                          .build();        }    }

Read parameter from a route

This example reads a mandatory parameter, namedid, and an optional parametername from the route path, and uses them to build a JSON document returned to the client, with content typeapplication/json.

@FunctionName("TriggerStringRoute")public HttpResponseMessage run(        @HttpTrigger(name = "req",             methods = {HttpMethod.GET},             authLevel = AuthorizationLevel.ANONYMOUS,            route = "trigger/{id}/{name=EMPTY}") // name is optional and defaults to EMPTY        HttpRequestMessage<Optional<String>> request,        @BindingName("id") String id,        @BindingName("name") String name,        final ExecutionContext context) {    // Item list    context.getLogger().info("Route parameters are: " + id);    // Convert and display    if (id == null) {        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)                        .body("Document not found.")                        .build();    }     else {        // return JSON from to the client        // Generate document        final String jsonDocument = "{\"id\":\"" + id + "\", " +                                         "\"description\": \"" + name + "\"}";        return request.createResponseBuilder(HttpStatus.OK)                        .header("Content-Type", "application/json")                        .body(jsonDocument)                        .build();    }}

Read POJO body from a POST request

Here's the code for theToDoItem class, referenced in this example:

public class ToDoItem {  private String id;  private String description;    public ToDoItem(String id, String description) {    this.id = id;    this.description = description;  }  public String getId() {    return id;  }  public String getDescription() {    return description;  }  @Override  public String toString() {    return "ToDoItem={id=" + id + ",description=" + description + "}";  }}

This example reads the body of a POST request. The request body gets automatically de-serialized into aToDoItem object, and is returned to the client, with content typeapplication/json. TheToDoItem parameter is serialized by the Functions runtime as it is assigned to thebody property of theHttpMessageResponse.Builder class.

@FunctionName("TriggerPojoPost")public HttpResponseMessage run(        @HttpTrigger(name = "req",             methods = {HttpMethod.POST},             authLevel = AuthorizationLevel.ANONYMOUS)        HttpRequestMessage<Optional<ToDoItem>> request,        final ExecutionContext context) {    // Item list    context.getLogger().info("Request body is: " + request.getBody().orElse(null));    // Check request body    if (!request.getBody().isPresent()) {        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)                        .body("Document not found.")                        .build();    }     else {        // return JSON from to the client        // Generate document        final ToDoItem body = request.getBody().get();        return request.createResponseBuilder(HttpStatus.OK)                        .header("Content-Type", "application/json")                        .body(body)                        .build();    }}

The following example shows a trigger binding in afunction.json file and aPowerShell function. The function looks for aname parameter either in the query string or the body of the HTTP request.

{  "bindings": [    {      "authLevel": "function",      "type": "httpTrigger",      "direction": "in",      "name": "Request",      "methods": [        "get",        "post"      ]    },    {      "type": "http",      "direction": "out",      "name": "Response"    }  ]}

using namespace System.Net# Input bindings are passed in via param block.param($Request, $TriggerMetadata)# Write to the Azure Functions log stream.Write-Host "PowerShell HTTP trigger function processed a request."# Interact with query parameters or the body of the request.$name = $Request.Query.Nameif (-not $name) {    $name = $Request.Body.Name}$body = "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."if ($name) {    $body = "Hello, $name. This HTTP triggered function executed successfully."}# Associate values to output bindings by calling 'Push-OutputBinding'.Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{    StatusCode = [HttpStatusCode]::OK    Body       = $body})

Attributes

Both theisolated worker model and thein-process model use theHttpTriggerAttribute to define the trigger binding. C# script instead uses a function.json configuration file as described in theC# scripting guide.

Decorators

Applies only to the Python v2 programming model.

For Python v2 functions defined using a decorator, the following properties for a trigger are defined in theroute decorator, which adds HttpTrigger and HttpOutput binding:

For Python functions defined by usingfunction.json, see theConfiguration section.

Annotations

In theJava functions runtime library, use theHttpTrigger annotation, which supports the following settings:

• authLevel
• dataType
• methods
• name
• route

Configuration

Applies only to the Python v1 programming model.

The following table explains the trigger configuration properties that you set in thefunction.json file, which differs by runtime version.

TheHttpTrigger annotation should be applied to a method parameter of one of the following types:

• HttpRequestMessage<T>.
• Any native Java types such as int, String, byte[].
• Nullable values using Optional.
• Any plain-old Java object (POJO) type.

Payload

using Microsoft.AspNetCore.Http;using Microsoft.AspNetCore.Mvc;using Microsoft.Azure.Functions.Worker;using FromBodyAttribute = Microsoft.Azure.Functions.Worker.Http.FromBodyAttribute;namespace AspNetIntegration{    public class BodyBindingHttpTrigger    {        [Function(nameof(BodyBindingHttpTrigger))]        public IActionResult Run([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req,            [FromBody] Person person)        {            return new OkObjectResult(person);        }    }    public record Person(string Name, int Age);}

Route parameters are defined using theroute setting of theHttpTrigger annotation. The following function code accepts two parameterscategory andid in the route and writes a response using both parameters.

package com.function;import java.util.*;import com.microsoft.azure.functions.annotation.*;import com.microsoft.azure.functions.*;public class HttpTriggerJava {    public HttpResponseMessage<String> HttpTrigger(            @HttpTrigger(name = "req",                         methods = {"get"},                         authLevel = AuthorizationLevel.FUNCTION,                         route = "products/{category:alpha}/{id:int}") HttpRequestMessage<String> request,            @BindingName("category") String category,            @BindingName("id") int id,            final ExecutionContext context) {        String message = String.format("Category  %s, ID: %d", category, id);        return request.createResponseBuilder(HttpStatus.OK).body(message).build();    }}

As an example, the following code defines aroute property for an HTTP trigger with two parameters,category andid:

@app.function_name(name="httpTrigger")@app.route(route="products/{category:alpha}/{id:int?}")

{    "bindings": [    {        "type": "httpTrigger",        "name": "req",        "direction": "in",        "methods": [ "get" ],        "route": "products/{category:alpha}/{id:int?}"    },    {        "type": "http",        "name": "res",        "direction": "out"    }    ]}

Route parameters declared in thefunction.json file are accessible as a property of the$Request.Params object.

$Category = $Request.Params.category$Id = $Request.Params.id$Message = "Category:" + $Category + ", ID: " + $IdPush-OutputBinding -Name Response -Value ([HttpResponseContext]@{    StatusCode = [HttpStatusCode]::OK    Body = $Message})

The function execution context is exposed via a parameter declared asfunc.HttpRequest. This instance allows a function to access data route parameters, query string values and methods that allow you to return HTTP responses.

Once defined, the route parameters are available to the function by calling theroute_params method.

import loggingimport azure.functions as funcdef main(req: func.HttpRequest) -> func.HttpResponse:    category = req.route_params.get('category')    id = req.route_params.get('id')    message = f"Category: {category}, ID: {id}"    return func.HttpResponse(message)

The following configuration shows how the{id} parameter is passed to the binding'srowKey.

{    "type": "table",    "direction": "in",    "name": "product",    "partitionKey": "products",    "tableName": "products",    "rowKey": "{id}"}

HTTP streams

You can now stream requests to and responses from your HTTP endpoint in Node.js v4 function apps. For more information, seeHTTP streams.

HTTP streams

HTTP streams support in Python lets you accept and return data from your HTTP endpoints using FastAPI request and response APIs enabled in your functions. These APIs enable the host to process data in HTTP messages as chunks instead of having to read an entire message into memory.

Prerequisites

• Azure Functions runtime version 4.34.1, or a later version.
• Python version 3.8, or a latersupported version.

Enable HTTP streams

HTTP streams are disabled by default. You need to enable this feature in your application settings and also update your code to use the FastAPI package. Note that when enabling HTTP streams, the function app will default to using HTTP streaming, and the original HTTP functionality will not work.

1. Add theazurefunctions-extensions-http-fastapi extension package to therequirements.txt file in the project, which should include at least these packages:

   azure-functionsazurefunctions-extensions-http-fastapi

2. Add this code to thefunction_app.py file in the project, which imports the FastAPI extension:

   from azurefunctions.extensions.http.fastapi import Request, StreamingResponse

3. When you deploy to Azure, add the followingapplication setting in your function app:

   "PYTHON_ENABLE_INIT_INDEXING": "1"

   When running locally, you also need to add these same settings to thelocal.settings.json project file.

HTTP streams examples

After you enable the HTTP streaming feature, you can create functions that stream data over HTTP.

This example is an HTTP triggered function that receives and processes streaming data from a client in real time. It demonstrates streaming upload capabilities that can be helpful for scenarios like processing continuous data streams and handling event data from IoT devices.

import azure.functions as funcfrom azurefunctions.extensions.http.fastapi import JSONResponse, Requestapp = func.FunctionApp(http_auth_level=func.AuthLevel.FUNCTION)@app.route(route="streaming_upload", methods=[func.HttpMethod.POST])async def streaming_upload(req: Request) -> JSONResponse:    """Handle streaming upload requests."""    # Process each chunk of data as it arrives    async for chunk in req.stream():        process_data_chunk(chunk)    # Once all data is received, return a JSON response indicating successful processing    return JSONResponse({"status": "Data uploaded and processed successfully"})def process_data_chunk(chunk: bytes):    """Process each data chunk."""    # Add custom processing logic here    pass

Calling HTTP streams

You must use an HTTP client library to make streaming calls to a function's FastAPI endpoints. The client tool or browser you're using might not natively support streaming or could only return the first chunk of data.

You can use a client script like this to send streaming data to an HTTP endpoint:

import httpx # Be sure to add 'httpx' to 'requirements.txt'import asyncioasync def stream_generator(file_path):    chunk_size = 2 * 1024  # Define your own chunk size    with open(file_path, 'rb') as file:        while chunk := file.read(chunk_size):            yield chunk            print(f"Sent chunk: {len(chunk)} bytes")async def stream_to_server(url, file_path):    timeout = httpx.Timeout(60.0, connect=60.0)    async with httpx.AsyncClient(timeout=timeout) as client:        response = await client.post(url, content=stream_generator(file_path))        return responseasync def stream_response(response):    if response.status_code == 200:        async for chunk in response.aiter_raw():            print(f"Received chunk: {len(chunk)} bytes")    else:        print(f"Error: {response}")async def main():    print('helloworld')    # Customize your streaming endpoint served from core tool in variable 'url' if different.    url = 'http://localhost:7071/api/streaming_upload'    file_path = r'<file path>'    response = await stream_to_server(url, file_path)    print(response)if __name__ == "__main__":    asyncio.run(main())

Note

Access to authenticated client information is currently only available for .NET languages. It also isn't supported in version 1.x of the Functions runtime.

Information regarding authenticated clients is available as aClaimsPrincipal, which is available as part of the request context as shown in the following example:

using System.Net;using Microsoft.AspNetCore.Mvc;using System.Security.Claims;public static IActionResult Run(HttpRequest req, ILogger log){    ClaimsPrincipal identities = req.HttpContext.User;    // ...    return new OkObjectResult();}

using System.Net;using Microsoft.AspNetCore.Mvc;using System.Security.Claims;using Newtonsoft.Json.Linq;public static void Run(JObject input, ClaimsPrincipal principal, ILogger log){    // ...    return;}

The authenticated user is available viaHTTP Headers.

When a level isn't explicitly set, authorization defaults to thefunction level.

When a level isn't explicitly set, the default authorization depends on the version of the Node.js model:

Note

When running functions locally, authorization is disabled regardless of the specified authorization level setting. After publishing to Azure, theauthLevel setting in your trigger is enforced. Keys are still required when runninglocally in a container.

Note

Webhook mode is only available for version 1.x of the Functions runtime. This change was made to improve the performance of HTTP triggers in version 2.x and higher.