Azure Functions HTTP-trigger

In het volgende voorbeeld ziet u een C#-functie die zoekt naar een parameter in de name queryreeks of de body van de HTTP-aanvraag. U ziet dat de retourwaarde wordt gebruikt voor de uitvoerbinding, maar er is geen kenmerk voor de retourwaarde vereist.

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

In het volgende voorbeeld ziet u een triggerbinding in function.jsbestand en een C#-scriptfunctie die gebruikmaakt van de binding. De functie zoekt naar een name parameter in de queryreeks of de body van de HTTP-aanvraag.

Dit is defunction.js bestand:

{
    "disabled": false,
    "bindings": [
        {
            "authLevel": "function",
            "name": "req",
            "type": "httpTrigger",
            "direction": "in",
            "methods": [
                "get",
                "post"
            ]
        },
        {
            "name": "$return",
            "type": "http",
            "direction": "out"
        }
    ]
}

In de configuratiesectie worden deze eigenschappen uitgelegd.

Hier is C#-scriptcode die wordt binden aan HttpRequest :

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static async Task<IActionResult> Run(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");
}

U kunt een binding maken met een aangepast object in plaats van HttpRequest . Dit object wordt gemaakt vanuit de body van de aanvraag en geparseerd als JSON. Op dezelfde manier kan een type worden doorgegeven aan de uitvoerbinding van het HTTP-antwoord en worden geretourneerd als de antwoord-body, samen met een 200 statuscode.

using System.Net;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public static string Run(Person person, ILogger log)
{   
    return person.Name != null
        ? (ActionResult)new OkObjectResult($"Hello, {person.Name}")
        : new BadRequestObjectResult("Please pass an instance of Person.");
}

public class Person {
     public string Name {get; set;}
}

• Parameter lezen uit de queryreeks
• De tekst van een POST-aanvraag lezen
• Parameter lezen uit een route
• POJO-body lezen uit een POST-aanvraag

In de volgende voorbeelden wordt de HTTP-triggerbinding weer gegeven.

Parameter lezen uit de queryreeks

In dit voorbeeld wordt een parameter met de naam gelezen uit de queryreeks en gebruikt om een JSON-document te maken dat wordt geretourneerd naar de id client, met het inhoudstype application/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();
    }
}

De tekst van een POST-aanvraag lezen

In dit voorbeeld wordt de body van een POST-aanvraag als een gelezen en gebruikt om een JSON-document te maken dat wordt geretourneerd naar de String client, met het inhoudstype application/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();
        }
    }

Parameter lezen uit een route

In dit voorbeeld worden een verplichte parameter, met de naam , en een optionele parameter uit het routepad gelezen en gebruikt om een JSON-document te bouwen dat wordt geretourneerd naar de client, met het id name inhoudstype application/json . T

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

POJO-body lezen uit een POST-aanvraag

Hier is de code voor de ToDoItem klasse waarnaar in dit voorbeeld wordt verwezen:

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

In dit voorbeeld wordt de body van een POST-aanvraag gelezen. De aanvraag body wordt automatisch gedeser serialiseerd in een -object en wordt geretourneerd naar de ToDoItem client, met het inhoudstype application/json . De ToDoItem parameter wordt geseraliseerd door de Functions-runtime omdat deze wordt toegewezen aan de body eigenschap van de klasse HttpMessageResponse.Builder .

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

In het volgende voorbeeld ziet u een triggerbinding in function.jsbestand en een JavaScript-functie die gebruikmaakt van de binding. De functie zoekt naar een name parameter in de queryreeks of de body van de HTTP-aanvraag.

Dit is defunction.js bestand:

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

In de configuratiesectie worden deze eigenschappen uitgelegd.

Dit is de JavaScript-code:

module.exports = 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"
        };
    }
    context.done();
};

In het volgende voorbeeld ziet u een triggerbinding in eenfunction.jsbestand en een PowerShell-functie. De functie zoekt naar een name parameter in de queryreeks of de body van de HTTP-aanvraag.

{
  "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.Name
if (-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
})

In het volgende voorbeeld ziet u een triggerbinding in eenfunction.jsbestand en een Python-functie die gebruikmaakt van de binding. De functie zoekt naar een name parameter in de queryreeks of de body van de HTTP-aanvraag.

Dit is defunction.js bestand:

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

In de configuratiesectie worden deze eigenschappen uitgelegd.

Dit is de Python-code:

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
        )

In dit voorbeeld wordt gedemonstreerd hoe u het kenmerk HttpTrigger gebruikt.

[FunctionName("HttpTriggerCSharp")]
public static Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous)] HttpRequest req)
{
    ...
}

Zie het triggervoorbeeld voor een volledig voorbeeld.

Kenmerken worden niet ondersteund door C# Script.

In dit voorbeeld wordt gedemonstreerd hoe u het kenmerk HttpTrigger gebruikt.

@FunctionName("HttpTriggerJava")
public HttpResponseMessage<String> HttpTrigger(
        @HttpTrigger(name = "req",
                     methods = {"get"},
                     authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<String> request,
        final ExecutionContext context) {

    ...
}

Zie het triggervoorbeeld voor een volledig voorbeeld.

Kenmerken worden niet ondersteund door JavaScript.

Kenmerken worden niet ondersteund door PowerShell.

Kenmerken worden niet ondersteund door Python.

U kunt elke routebeperking voor web-API's gebruiken met uw parameters. De volgende C#-functiecode maakt gebruik van beide parameters.

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;

public static IActionResult Run(HttpRequest req, string category, int? id, ILogger log)
{
    var message = String.Format($"Category: {category}, ID: {id}");
    return (ActionResult)new OkObjectResult(message);
}

U kunt elke routebeperking voor web-API's gebruiken met uw parameters. De volgende C#-functiecode maakt gebruik van beide parameters.

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;

public static IActionResult Run(HttpRequest req, string category, int? id, ILogger log)
{
    var message = String.Format($"Category: {category}, ID: {id}");
    return (ActionResult)new OkObjectResult(message);
}

De context van de uitvoering van de functie is eigenschappen zoals gedeclareerd in het HttpTrigger kenmerk . Met het kenmerk kunt u routeparameters, autorisatieniveaus, HTTP-woorden en het binnenkomende aanvraag-exemplaar definiëren.

Routeparameters worden gedefinieerd via het HttpTrigger kenmerk .

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

In Node levert de Functions-runtime de aanvraag body van het context -object. Zie het JavaScript-triggervoorbeeld voor meer informatie.

In het volgende voorbeeld ziet u hoe u routeparameters uit context.bindingData leest.

module.exports = function (context, req) {

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

    context.res = {
        body: message;
    }

    context.done();
}

Routeparameters die zijn gedeclareerd infunction.json-file zijn toegankelijk als een eigenschap van het $Request.Params object.

$Category = $Request.Params.category
$Id = $Request.Params.id

$Message = "Category:" + $Category + ", ID: " + $Id

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $Message
})

De context van de uitvoering van de functie wordt beschikbaar gemaakt via een parameter die is gedeclareerd als func.HttpRequest . Met dit exemplaar kan een functie toegang krijgen tot gegevensrouteparameters, queryreekswaarden en methoden waarmee u HTTP-antwoorden kunt retourneren.

Zodra de routeparameters zijn gedefinieerd, zijn ze beschikbaar voor de functie door de methode aan te route_params roepen.

import logging

import azure.functions as func

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

Informatie over geverifieerde clients is beschikbaar als een ClaimsPrincipal. De ClaimsPrincipal is beschikbaar als onderdeel van de aanvraagcontext, zoals wordt weergegeven in het volgende voorbeeld:

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

De ClaimsPrincipal kan ook gewoon worden opgenomen als een extra parameter in de functiehandtekening:

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

Informatie over geverifieerde clients is beschikbaar als een ClaimsPrincipal. De ClaimsPrincipal is beschikbaar als onderdeel van de aanvraagcontext, zoals wordt weergegeven in het volgende voorbeeld:

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

De ClaimsPrincipal kan ook gewoon worden opgenomen als een extra parameter in de functiehandtekening:

#r "Newtonsoft.Json"

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

De geverifieerde gebruiker is beschikbaar via HTTP-headers.

De geverifieerde gebruiker is beschikbaar via HTTP-headers.

De geverifieerde gebruiker is beschikbaar via HTTP-headers.

De geverifieerde gebruiker is beschikbaar via HTTP-headers.