Wyzwalacz HTTP usługi Azure Functions

Model programowania w języku Python w wersji 2 umożliwia definiowanie powiązań przy użyciu dekoratorów bezpośrednio w kodzie funkcji języka Python. Aby uzyskać więcej informacji, zobacz przewodnik dla deweloperów języka Python.

Model programowania w języku Python w wersji 1 wymaga zdefiniowania powiązań w osobnym pliku function.json w folderze funkcji. Aby uzyskać więcej informacji, zobacz przewodnik dla deweloperów języka Python.

W poniższym przykładzie pokazano wyzwalacz HTTP, który zwraca odpowiedź "hello, world" jako IActionResult przy użyciu integracji ASP.NET Core w środowisku .NET Isolated:

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

W poniższym przykładzie pokazano wyzwalacz HTTP, który zwraca odpowiedź "hello world" jako obiekt HttpResponseData :

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

W poniższym przykładzie pokazano funkcję języka C#, która wyszukuje name parametr w ciągu zapytania lub w treści żądania HTTP. Zwróć uwagę, że wartość zwracana jest używana dla powiązania wyjściowego, ale atrybut wartości zwracanej nie jest wymagany.

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

W poniższym przykładzie przedstawiono funkcję TypeScript wyzwalacza HTTP. Funkcja szuka parametru name w ciągu zapytania lub treści żądania HTTP.

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

Przykłady języka TypeScript nie są udokumentowane dla modelu w wersji 3.

W poniższym przykładzie przedstawiono funkcję JavaScript wyzwalacza HTTP. Funkcja szuka parametru name w ciągu zapytania lub treści żądania HTTP.

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}!` };
    },
});

W poniższym przykładzie pokazano powiązanie wyzwalacza w pliku function.json i funkcję Języka JavaScript, która używa powiązania. Funkcja szuka parametru name w ciągu zapytania lub treści żądania HTTP.

Oto plik function.json:

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

W sekcji konfiguracji opisano te właściwości.

Oto kod JavaScript:

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

W tym przykładzie są używane strumienie HTTP do zwracania fragmentowanych danych odpowiedzi.

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")

Aby dowiedzieć się więcej, w tym jak włączyć strumienie HTTP w projekcie, zobacz Strumienie HTTP.

W tym przykładzie pokazano powiązanie wyzwalacza i funkcję języka Python, która używa powiązania. Funkcja szuka parametru name w ciągu zapytania lub treści żądania HTTP.

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
        )

W tym przykładzie pokazano powiązanie wyzwalacza i funkcję języka Python, która używa powiązania. Funkcja szuka parametru name w ciągu zapytania lub treści żądania HTTP.

Oto plik function.json:

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

W sekcji konfiguracji opisano te właściwości.

Oto kod języka Python:

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
        )

W aplikacjach HttpTriggerAttribute funkcji modelu izolowanego procesu roboczego obsługiwane są następujące parametry:

W funkcjach przetwarzania HttpTriggerAttribute funkcja obsługuje następujące parametry:

W poniższej tabeli opisano właściwości, które można ustawić dla options obiektu przekazanego app.http() do metody .

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

Typ danych wejściowych wyzwalacza jest zadeklarowany jako jeden z następujących typów:

Gdy parametr wyzwalacza ma typ HttpRequestData lub HttpRequest, typy niestandardowe mogą być również powiązane z innymi parametrami przy użyciu polecenia Microsoft.Azure.Functions.Worker.Http.FromBodyAttribute. Użycie tego atrybutu wymaga Microsoft.Azure.Functions.Worker.Extensions.Http wersji 3.1.0 lub nowszej. Jest to inny typ niż podobny atrybut w pliku Microsoft.AspNetCore.Mvc. W przypadku korzystania z integracji ASP.NET Core potrzebna jest w pełni kwalifikowana dokumentacja lub using instrukcja. W tym przykładzie pokazano, jak za pomocą atrybutu pobrać tylko zawartość treści, a jednocześnie mieć dostęp do pełnej HttpRequestzawartości przy użyciu ASP.NET Core integracji:

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

Typ danych wejściowych wyzwalacza jest zadeklarowany jako HttpRequest typ niestandardowy lub niestandardowy. Jeśli wybierzesz opcję HttpRequest, uzyskasz pełny dostęp do obiektu żądania. W przypadku typu niestandardowego środowisko uruchomieniowe próbuje przeanalizować treść żądania JSON w celu ustawienia właściwości obiektu.

Poniższy kod funkcji akceptuje dwa parametry category i id w trasie i zapisuje odpowiedź przy użyciu obu parametrów.

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

Poniższy kod funkcji języka C# akceptuje dwa parametry category i id w trasie i zapisuje odpowiedź przy użyciu obu parametrów.

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

Na przykład poniższy kod Języka TypeScript definiuje route właściwość wyzwalacza HTTP z dwoma parametrami category i id. Przykład odczytuje parametry z żądania i zwraca ich wartości w odpowiedzi.

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

Przykłady języka TypeScript nie są udokumentowane dla modelu w wersji 3.

Na przykład poniższy kod JavaScript definiuje route właściwość wyzwalacza HTTP z dwoma parametrami category i id. Przykład odczytuje parametry z żądania i zwraca ich wartości w odpowiedzi.

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

Na przykład poniższy plik function.json definiuje route właściwość wyzwalacza HTTP z dwoma parametrami category i id:

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

Środowisko uruchomieniowe usługi Functions udostępnia treść żądania z context obiektu. W poniższym przykładzie pokazano, jak odczytywać parametry trasy z pliku 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?}")

W pliku 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,
});

Przykłady języka TypeScript nie są udokumentowane dla modelu w wersji 3.

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

Uwierzytelniony użytkownik jest dostępny za pośrednictwem nagłówków HTTP.

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

Alternatywnie można po prostu dołączyć element ClaimsPrincipal jako dodatkowy parametr w podpisie funkcji:

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

Autoryzacja jest domyślnie ustawiona na anonymous poziom .

Autoryzacja jest domyślnie ustawiona na function poziom .