Azure Cosmos DB utdatabindning för Azure Functions 2.x och senare

Azure Functions stöder två programmeringsmodeller för Python. Hur du definierar dina bindningar beror på din valda programmeringsmodell.

Den här artikeln stöder båda programmeringsmodellerna.

En C#-funktion kan skapas med något av följande C#-lägen:

• Isolerad arbetsmodell: Kompilerad C#-funktion som körs i en arbetsprocess som är isolerad från körningen. Isolerad arbetsprocess krävs för att stödja C#-funktioner som körs på LTS- och icke-LTS-versioner .NET och .NET Framework. Tillägg för isolerade arbetsprocessfunktioner använder Microsoft.Azure.Functions.Worker.Extensions.* namnområden.
• Processmodell: Kompilerad C#-funktion som körs i samma process som Functions-körningen. I en variant av den här modellen kan Functions köras med C#-skript, vilket främst stöds för redigering av C#-portalen. Tillägg för processfunktioner använder Microsoft.Azure.WebJobs.Extensions.* namnområden.

Go-stöd finns för närvarande inte tillgängligt för denna bindning.

• Köutlösare, spara meddelande till databasen via returvärde
• HTTP-utlösare, spara ett dokument i databasen via returvärde
• HTTP-utlösare, spara ett dokument i databasen via OutputBinding
• HTTP-utlösare, spara flera dokument i databasen via OutputBinding

Köutlösare, spara meddelande till databasen via returvärde

I följande exempel visas en Java funktion som lägger till ett dokument i en databas med data från ett meddelande i Queue Storage.

@FunctionName("getItem")
@CosmosDBOutput(name = "database",
  databaseName = "ToDoList",
  collectionName = "Items",
  connectionStringSetting = "AzureCosmosDBConnection")
public String cosmosDbQueryById(
    @QueueTrigger(name = "msg",
      queueName = "myqueue-items",
      connection = "AzureWebJobsStorage")
    String message,
    final ExecutionContext context)  {
     return "{ id: \"" + System.currentTimeMillis() + "\", Description: " + message + " }";
   }

HTTP-utlösare, spara ett dokument i databasen via returvärde

I följande exempel visas en Java funktion vars signatur kommenteras med @CosmosDBOutput och har returvärde av typen String. JSON-dokumentet som returneras av funktionen skrivs automatiskt till motsvarande Azure Cosmos DB samling.

    @FunctionName("WriteOneDoc")
    @CosmosDBOutput(name = "database",
      databaseName = "ToDoList",
      collectionName = "Items",
      connectionStringSetting = "Cosmos_DB_Connection_String")
    public String run(
            @HttpTrigger(name = "req",
              methods = {HttpMethod.GET, HttpMethod.POST},
              authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<String>> request,
            final ExecutionContext context) {

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());

        // Parse query parameter
        String query = request.getQueryParameters().get("desc");
        String name = request.getBody().orElse(query);

        // Generate random ID
        final int id = Math.abs(new Random().nextInt());

        // Generate document
        final String jsonDocument = "{\"id\":\"" + id + "\", " +
                                    "\"description\": \"" + name + "\"}";

        context.getLogger().info("Document to be saved: " + jsonDocument);

        return jsonDocument;
    }

HTTP-utlösare, spara ett dokument i databasen via OutputBinding

I följande exempel visas en Java funktion som skriver ett dokument till Azure Cosmos DB via en OutputBinding<T> utdataparameter. I det här exemplet måste parametern outputItem kommenteras med @CosmosDBOutput, inte funktionssignaturen. Med hjälp av OutputBinding<T> kan funktionen dra nytta av bindningen för att skriva dokumentet till Azure Cosmos DB samtidigt som du kan returnera ett annat värde till funktionsanroparen, till exempel ett JSON- eller XML-dokument.

    @FunctionName("WriteOneDocOutputBinding")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req",
              methods = {HttpMethod.GET, HttpMethod.POST},
              authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<String>> request,
            @CosmosDBOutput(name = "database",
              databaseName = "ToDoList",
              collectionName = "Items",
              connectionStringSetting = "Cosmos_DB_Connection_String")
            OutputBinding<String> outputItem,
            final ExecutionContext context) {

        // Parse query parameter
        String query = request.getQueryParameters().get("desc");
        String name = request.getBody().orElse(query);

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());

        // Generate random ID
        final int id = Math.abs(new Random().nextInt());

        // Generate document
        final String jsonDocument = "{\"id\":\"" + id + "\", " +
                                    "\"description\": \"" + name + "\"}";

        context.getLogger().info("Document to be saved: " + jsonDocument);

        // Set outputItem's value to the JSON document to be saved
        outputItem.setValue(jsonDocument);

        // return a different document to the browser or calling client.
        return request.createResponseBuilder(HttpStatus.OK)
                      .body("Document created successfully.")
                      .build();
    }

HTTP-utlösare, spara flera dokument i databasen via OutputBinding

I följande exempel visas en Java funktion som skriver flera dokument till Azure Cosmos DB via en OutputBinding<T>-utdataparameter. I det här exemplet kommenteras parametern outputItem med @CosmosDBOutput, inte funktionssignaturen. Utdataparametern outputItem har en lista med ToDoItem objekt som mallparametertyp. Med OutputBinding<T> kan funktionen dra nytta av bindningen för att skriva dokumenten till Azure Cosmos DB samtidigt som du kan returnera ett annat värde till funktionsanroparen, till exempel ett JSON- eller XML-dokument.

    @FunctionName("WriteMultipleDocsOutputBinding")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req",
              methods = {HttpMethod.GET, HttpMethod.POST},
              authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<String>> request,
            @CosmosDBOutput(name = "database",
              databaseName = "ToDoList",
              collectionName = "Items",
              connectionStringSetting = "Cosmos_DB_Connection_String")
            OutputBinding<List<ToDoItem>> outputItem,
            final ExecutionContext context) {

        // Parse query parameter
        String query = request.getQueryParameters().get("desc");
        String name = request.getBody().orElse(query);

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());

        // Generate documents
        List<ToDoItem> items = new ArrayList<>();

        for (int i = 0; i < 5; i ++) {
          // Generate random ID
          final int id = Math.abs(new Random().nextInt());

          // Create ToDoItem
          ToDoItem item = new ToDoItem(String.valueOf(id), name);

          items.add(item);
        }

        // Set outputItem's value to the list of POJOs to be saved
        outputItem.setValue(items);
        context.getLogger().info("Document to be saved: " + items);

        // return a different document to the browser or calling client.
        return request.createResponseBuilder(HttpStatus.OK)
                      .body("Documents created successfully.")
                      .build();
    }

I Java functions runtime-biblioteket använder du @CosmosDBOutput-kommentaren på parametrar som skrivs till Azure Cosmos DB. Anteckningsparametertypen ska vara OutputBinding<T>, där T antingen är en inbyggd Java typ eller en POJO.

I följande exempel visas hur du skriver data till Azure Cosmos DB med hjälp av en utdatabindning. Bindningen deklareras i funktionens konfigurationsfil (functions.json) och tar data från ett kömeddelande och skriver ut till ett Azure Cosmos DB dokument.

{ 
  "name": "EmployeeDocument",
  "type": "cosmosDB",
  "databaseName": "MyDatabase",
  "collectionName": "MyCollection",
  "createIfNotExists": true,
  "connectionStringSetting": "MyStorageConnectionAppSetting",
  "direction": "out" 
} 

I filen run.ps1 mappas objektet som returneras från funktionen till ett EmployeeDocument objekt som sparas i databasen.

param($QueueItem, $TriggerMetadata) 

Push-OutputBinding -Name EmployeeDocument -Value @{ 
    id = $QueueItem.name + '-' + $QueueItem.employeeId 
    name = $QueueItem.name 
    employeeId = $QueueItem.employeeId 
    address = $QueueItem.address 
} 

I följande exempel visas hur du skriver ett dokument till en Azure Cosmos DB databas som utdata för en funktion. Exemplet beror på om du använder programmeringsmodellen v1 eller v2 Python.

import logging
import azure.functions as func

app = func.FunctionApp()

@app.route()
@app.cosmos_db_output(arg_name="documents", 
                      database_name="DB_NAME",
                      collection_name="COLLECTION_NAME",
                      create_if_not_exists=True,
                      connection_string_setting="CONNECTION_SETTING")
def main(req: func.HttpRequest, documents: func.Out[func.Document]) -> func.HttpResponse:
    request_body = req.get_body()
    documents.set(func.Document.from_json(request_body))
    return 'OK'

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "cosmosDB",
      "direction": "out",
      "name": "doc",
      "databaseName": "demodb",
      "collectionName": "data",
      "createIfNotExists": "true",
      "connectionStringSetting": "AzureCosmosDBConnectionString"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}

import azure.functions as func

def main(req: func.HttpRequest, doc: func.Out[func.Document]) -> func.HttpResponse:

    request_body = req.get_body()

    doc.set(func.Document.from_json(request_body))

    return 'OK'

Attribut

C#-bibliotek i både processprocess och isolerad arbetsprocess använder attribut för att definiera funktionen. C#-skriptet använder i stället en function.json konfigurationsfil enligt beskrivningen i C#-skriptguiden.

Dekoratörer

Applies endast till programmeringsmodellen Python v2.

För Python v2-funktioner som definierats med hjälp av en dekoratör, följande egenskaper på cosmos_db_output:

Information om Python funktioner som definieras med hjälp av function.json finns i avsnittet Configuration.

Kommentarer

Från Java functions runtime-biblioteket använder du @CosmosDBOutput kommentar på parametrar som skriver till Azure Cosmos DB. Kommentaren stöder följande egenskaper:

• Namn
• connectionStringSetting
• databaseName
• collectionName
• createIfNotExists
• Datatyp
• partitionKey
• preferredLocations
• användFleraSkrivPlatser

Konfiguration

Applies endast till programmeringsmodellen Python v1.

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json , där egenskaperna skiljer sig åt efter tilläggsversion:

Utdatafunktionsparametern måste definieras som func.Out[func.Document]. Mer information finns i utdataexemplet .

Parametertypen som stöds av Cosmos DB-utdatabindningen beror på functions-körningsversionen, tilläggspaketversionen och den C#-modalitet som används.