Http-utlösare för Azure Functions

Med programmeringsmodellen Python v2 kan du definiera bindningar med hjälp av dekoratörer direkt i python-funktionskoden. Mer information finns i utvecklarguiden för Python.

Programmeringsmodellen Python v1 kräver att du definierar bindningar i en separat function.json fil i funktionsmappen. Mer information finns i utvecklarguiden för Python.

I följande exempel visas en HTTP-utlösare som returnerar ett "hello, world"-svar som en IActionResult med hjälp av ASP.NET Core-integrering i .NET Isolerad:

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

I följande exempel visas en HTTP-utlösare som returnerar ett "hello world"-svar som ett HttpResponseData-objekt :

[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;
}

I följande exempel visas en C#-funktion som söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran. Observera att returvärdet används för utdatabindningen, men ett returvärdeattribut krävs inte.

[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");
}

I följande exempel visas en TYPEScript-funktion för HTTP-utlösare. Funktionen söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran.

import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || (await request.text()) || 'world';

    return { body: `Hello, ${name}!` };
}

app.http('httpTrigger1', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: httpTrigger1,
});

TypeScript-exempel dokumenteras inte för model v3.

I följande exempel visas en JAVAScript-funktion för HTTP-utlösare. Funktionen söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran.

const { app } = require('@azure/functions');

app.http('httpTrigger1', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        const name = request.query.get('name') || (await request.text()) || 'world';

        return { body: `Hello, ${name}!` };
    },
});

I följande exempel visas en utlösarbindning i en function.json-fil och en JavaScript-funktion som använder bindningen. Funktionen söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran.

Här är den function.json filen:

{
    "disabled": false,    
    "bindings": [
        {
            "authLevel": "function",
            "type": "httpTrigger",
            "direction": "in",
            "name": "req"
        },
        {
            "type": "http",
            "direction": "out",
            "name": "res"
        }
    ]
}

I konfigurationsavsnittet förklaras dessa egenskaper.

Här är JavaScript-koden:

module.exports = async function(context, req) {
    context.log('Node.js HTTP trigger function processed a request. RequestUri=%s', req.originalUrl);

    if (req.query.name || (req.body && req.body.name)) {
        context.res = {
            // status defaults to 200 */
            body: "Hello " + (req.query.name || req.body.name)
        };
    }
    else {
        context.res = {
            status: 400,
            body: "Please pass a name on the query string or in the request body"
        };
    }
};

I det här exemplet används HTTP-strömmar för att returnera segmenterade svarsdata.

import time

import azure.functions as func
from azurefunctions.extensions.http.fastapi import Request, StreamingResponse

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)


def generate_sensor_data():
    """Generate real-time sensor data."""
    for i in range(10):
        # Simulate temperature and humidity readings
        temperature = 20 + i
        humidity = 50 + i
        yield f"data: {{'temperature': {temperature}, 'humidity': {humidity}}}\n\n"
        time.sleep(1)


@app.route(route="stream", methods=[func.HttpMethod.GET])
async def stream_sensor_data(req: Request) -> StreamingResponse:
    """Endpoint to stream real-time sensor data."""
    return StreamingResponse(generate_sensor_data(), media_type="text/event-stream")

Mer information, inklusive hur du aktiverar HTTP-strömmar i projektet, finns i HTTP-strömmar.

Det här exemplet visar en utlösarbindning och en Python-funktion som använder bindningen. Funktionen söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran.

import azure.functions as func
import logging

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)
def test_function(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')
    return func.HttpResponse(
        "This HTTP triggered function executed successfully.",
        status_code=200
        )

Det här exemplet visar en utlösarbindning och en Python-funktion som använder bindningen. Funktionen söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran.

Här är den function.json filen:

{
    "scriptFile": "__init__.py",
    "disabled": false,    
    "bindings": [
        {
            "authLevel": "function",
            "type": "httpTrigger",
            "direction": "in",
            "name": "req"
        },
        {
            "type": "http",
            "direction": "out",
            "name": "$return"
        }
    ]
}

I konfigurationsavsnittet förklaras dessa egenskaper.

Här är Python-koden:

import logging
import azure.functions as func


def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        return func.HttpResponse(f"Hello {name}!")
    else:
        return func.HttpResponse(
            "Please pass a name on the query string or in the request body",
            status_code=400
        )

I funktionsappar för HttpTriggerAttribute isolerade arbetsmodeller stöder följande parametrar:

I processfunktionerHttpTriggerAttribute stöder följande parametrar:

I följande tabell förklaras de egenskaper som du kan ange för objektet options som skickas app.http() till metoden.

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json .

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json .

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json .

Indatatypen utlösare deklareras som en av följande typer:

När utlösarparametern är av typen HttpRequestData eller HttpRequestkan anpassade typer också bindas till andra parametrar med hjälp av Microsoft.Azure.Functions.Worker.Http.FromBodyAttribute. Användning av det här attributet kräver Microsoft.Azure.Functions.Worker.Extensions.Http version 3.1.0 eller senare. Det här är en annan typ än det liknande attributet i Microsoft.AspNetCore.Mvc. När du använder ASP.NET Core-integrering behöver du en fullständigt kvalificerad referens eller using instruktion. Det här exemplet visar hur du använder attributet för att bara hämta brödtextinnehållet samtidigt som du har åtkomst till hela HttpRequest, med hjälp av ASP.NET Core-integrering:

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);
}

Indatatypen för utlösaren deklareras som antingen HttpRequest eller en anpassad typ. Om du väljer HttpRequestfår du fullständig åtkomst till begärandeobjektet. För en anpassad typ försöker körningen parsa JSON-begärandetexten för att ange objektegenskaperna.

Följande funktionskod accepterar två parametrar category och id i vägen och skriver ett svar med båda parametrarna.

[Function("HttpTrigger1")]
public static HttpResponseData Run([HttpTrigger(AuthorizationLevel.Function, "get", "post",
Route = "products/{category:alpha}/{id:int?}")] HttpRequestData req, string category, int? id,
FunctionContext executionContext)
{
    var logger = executionContext.GetLogger("HttpTrigger1");
    logger.LogInformation("C# HTTP trigger function processed a request.");

    var message = String.Format($"Category: {category}, ID: {id}");
    var response = req.CreateResponse(HttpStatusCode.OK);
    response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
    response.WriteString(message);

    return response;
}

Följande C#-funktionskod accepterar två parametrar category och id i vägen och skriver ett svar med båda parametrarna.

[FunctionName("Function1")]
public static IActionResult Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "products/{category:alpha}/{id:int?}")] HttpRequest req,
string category, int? id, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    var message = String.Format($"Category: {category}, ID: {id}");
    return (ActionResult)new OkObjectResult(message);
}

Till exempel definierar följande TypeScript-kod en route egenskap för en HTTP-utlösare med två parametrar och category id. Exemplet läser parametrarna från begäran och returnerar deras värden i svaret.

import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    const category = request.params.category;
    const id = request.params.id;

    return { body: `Category: ${category}, ID: ${id}` };
}

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    route: 'products/{category:alpha}/{id:int?}',
    handler: httpTrigger1,
});

TypeScript-exempel dokumenteras inte för model v3.

Följande JavaScript-kod definierar till exempel en route egenskap för en HTTP-utlösare med två parametrar category och id. Exemplet läser parametrarna från begäran och returnerar deras värden i svaret.

const { app } = require('@azure/functions');

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    route: 'products/{category:alpha}/{id:int?}',
    handler: async (request, context) => {
        const category = request.params.category;
        const id = request.params.id;

        return { body: `Category: ${category}, ID: ${id}` };
    },
});

Följande function.json-fil definierar till exempel en route egenskap för en HTTP-utlösare med två parametrar och category id:

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

Functions-körningen innehåller begärandetexten context från objektet. I följande exempel visas hur du läser vägparametrar från context.bindingData.

module.exports = async function (context, req) {

    var category = context.bindingData.category;
    var id = context.bindingData.id;
    var message = `Category: ${category}, ID: ${id}`;

    context.res = {
        body: message;
    }
}

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

I filen function.json :

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

@app.table_input(arg_name="product", table_name="products", 
                 row_key="{id}", partition_key="products",
                 connection="AzureWebJobsStorage")

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

import { app, HttpRequest, HttpResponseInit, input, InvocationContext } from '@azure/functions';

const tableInput = input.table({
    connection: 'MyStorageConnectionAppSetting',
    partitionKey: 'products',
    tableName: 'products',
    rowKey: '{id}',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    return { jsonBody: context.extraInputs.get(tableInput) };
}

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    route: 'products/{id}',
    extraInputs: [tableInput],
    handler: httpTrigger1,
});

TypeScript-exempel dokumenteras inte för model v3.

const { app, input } = require('@azure/functions');

const tableInput = input.table({
    connection: 'MyStorageConnectionAppSetting',
    partitionKey: 'products',
    tableName: 'products',
    rowKey: '{id}',
});

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    route: 'products/{id}',
    extraInputs: [tableInput],
    handler: async (request, context) => {
        return { jsonBody: context.extraInputs.get(tableInput) };
    },
});

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

Den autentiserade användaren är tillgänglig via HTTP-huvuden.

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();
}

Alternativt kan ClaimsPrincipal helt enkelt inkluderas som en extra parameter i funktionssignaturen:

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;
}

Auktorisering är standardnivå anonymous .

Auktorisering är standardnivå function .