Azure Functions 2. x Azure Cosmos DB kötéseiAzure Cosmos DB bindings for Azure Functions 2.x

Ez a cikk azt ismerteti, hogyan használhatók Azure Cosmos db kötések Azure functions 2. x verzióban.This article explains how to work with Azure Cosmos DB bindings in Azure Functions 2.x. Az Azure Functions támogatja a-trigger, bemeneti és kimeneti kötések az Azure Cosmos DB.Azure Functions supports trigger, input, and output bindings for Azure Cosmos DB.

Megjegyzés

Ez a cikk a Azure functions 2. x verziójának.This article is for Azure Functions version 2.x. További információ a kötések használatáról az 1. x függvényeknél: Azure Cosmos db kötések Azure functions 1. x verzióhoz.For information about how to use these bindings in Functions 1.x, see Azure Cosmos DB bindings for Azure Functions 1.x.

Ennek a kötésnek a DocumentDB eredetileg neve.This binding was originally named DocumentDB. A functions 2. x verziójában a trigger, a kötések és a csomag neve Cosmos DB.In Functions version 2.x, the trigger, bindings, and package are all named Cosmos DB.

Ez az információ az Azure Functions-fejlesztők számára.This is reference information for Azure Functions developers. Ha most ismerkedik az Azure Functions, indítsa el az alábbi forrásanyagokat:If you're new to Azure Functions, start with the following resources:

Támogatott API-kSupported APIs

Az Azure Cosmos DB-kötések csak az SQL API-val használhatók.Azure Cosmos DB bindings are only supported for use with the SQL API. Az összes többi Azure Cosmos DB API-k, kell az adatbázis eléréséhez fog a funkció a statikus ügyfél segítségével az API-hoz, beleértve a Azure Cosmos DB MongoDB API-, Cassandra API, Gremlin API, és Table API.For all other Azure Cosmos DB APIs, you should access the database from your function by using the static client for your API, including Azure Cosmos DB's API for MongoDB, Cassandra API, Gremlin API, and Table API.

Csomagok – 2.x függvényekPackages - Functions 2.x

A függvények Azure Cosmos DB kötései a 2. x verzióhoz tartoznak a Microsoft. Azure. webjobs. Extensions. CosmosDB NuGet csomag 3. x verziójában.The Azure Cosmos DB bindings for Functions version 2.x are provided in the Microsoft.Azure.WebJobs.Extensions.CosmosDB NuGet package, version 3.x. A kötések forráskódja a azure-webjobs-sdk-bővítmények GitHub-adattárban.Source code for the bindings is in the azure-webjobs-sdk-extensions GitHub repository.

Az alábbi táblázat bemutatja, hogyan lehet ezt a kötést támogatása hozzáadva minden fejlesztési környezetben.The following table tells how to add support for this binding in each development environment.

Fejlesztési környezetDevelopment environment A támogatás hozzáadásaTo add support in
Functions 2.xFunctions 2.x
Helyi fejlesztés – C# osztálytárLocal development - C# class library A csomag telepítéseInstall the package
Helyi fejlesztés – C# parancsfájl, JavaScript, F#, Java és Python nyelvenLocal development - C# script, JavaScript, F#, Java and Python A bővítmény regisztrálásaRegister the extension
A fejlesztői portálPortal development Telepítse a kimeneti kötés hozzáadása soránInstall when adding output binding

Megtudhatja, hogyan lehet frissíteni a létező kötés bővítmények a portálon való ismételt közzétételéhez a függvényalkalmazás projektjét nélkül, tekintse meg a a bővítmények frissítése.To learn how to update existing binding extensions in the portal without having to republish your function app project, see Update your extensions.

EseményindítóTrigger

Használja az Azure Cosmos DB-eseményindító a Azure Cosmos DB módosítási hírcsatorna figyeljen a beszúrások és frissítések partíciók között.The Azure Cosmos DB Trigger uses the Azure Cosmos DB Change Feed to listen for inserts and updates across partitions. A módosítási hírcsatorna beszúrások és frissítéseket, törléseket nem tesz közzé.The change feed publishes inserts and updates, not deletions.

Az eseményindító – példaTrigger - example

Tekintse meg az adott nyelvű példa:See the language-specific example:

Trigger-példák kihagyásaSkip trigger examples

Eseményindító - C#-példaTrigger - C# example

A következő példa bemutatja egy C#-függvény , amelyek akkor aktiválódnak, ha nincsenek be vagy frissít a megadott adatbázis és gyűjtemény.The following example shows a C# function that is invoked when there are inserts or updates in the specified database and collection.

using Microsoft.Azure.Documents;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using System.Collections.Generic;
using Microsoft.Extensions.Logging;

namespace CosmosDBSamplesV2
{
    public static class CosmosTrigger
    {
        [FunctionName("CosmosTrigger")]
        public static void Run([CosmosDBTrigger(
            databaseName: "ToDoItems",
            collectionName: "Items",
            ConnectionStringSetting = "CosmosDBConnection",
            LeaseCollectionName = "leases",
            CreateLeaseCollectionIfNotExists = true)]IReadOnlyList<Document> documents,
            ILogger log)
        {
            if (documents != null && documents.Count > 0)
            {
                log.LogInformation($"Documents modified: {documents.Count}");
                log.LogInformation($"First document Id: {documents[0].Id}");
            }
        }
    }
}

Trigger-példák kihagyásaSkip trigger examples

Eseményindító - C#-szkript példaTrigger - C# script example

Az alábbi példa bemutatja egy kötést a Cosmos DB-eseményindító egy function.json fájl és a egy C#-szkriptfüggvény , amely a kötés használja.The following example shows a Cosmos DB trigger binding in a function.json file and a C# script function that uses the binding. A függvény naplóüzenetek ír, Cosmos DB-rekordok módosításakor.The function writes log messages when Cosmos DB records are modified.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

{
    "type": "cosmosDBTrigger",
    "name": "documents",
    "direction": "in",
    "leaseCollectionName": "leases",
    "connectionStringSetting": "<connection-app-setting>",
    "databaseName": "Tasks",
    "collectionName": "Items",
    "createLeaseCollectionIfNotExists": true
}

Íme a C#-szkriptkódot:Here's the C# script code:

    #r "Microsoft.Azure.DocumentDB.Core"

    using System;
    using Microsoft.Azure.Documents;
    using System.Collections.Generic;
    using Microsoft.Extensions.Logging;

    public static void Run(IReadOnlyList<Document> documents, ILogger log)
    {
      log.LogInformation("Documents modified " + documents.Count);
      log.LogInformation("First document Id " + documents[0].Id);
    }

Trigger-példák kihagyásaSkip trigger examples

Eseményindító - JavaScript-példaTrigger - JavaScript example

Az alábbi példa bemutatja egy kötést a Cosmos DB-eseményindító egy function.json fájl és a egy JavaScript-függvény , amely a kötés használja.The following example shows a Cosmos DB trigger binding in a function.json file and a JavaScript function that uses the binding. A függvény naplóüzenetek ír, Cosmos DB-rekordok módosításakor.The function writes log messages when Cosmos DB records are modified.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

{
    "type": "cosmosDBTrigger",
    "name": "documents",
    "direction": "in",
    "leaseCollectionName": "leases",
    "connectionStringSetting": "<connection-app-setting>",
    "databaseName": "Tasks",
    "collectionName": "Items",
    "createLeaseCollectionIfNotExists": true
}

A következő JavaScript-kódot:Here's the JavaScript code:

    module.exports = function (context, documents) {
      context.log('First document Id modified : ', documents[0].id);

      context.done();
    }

Eseményindító - Java-példábanTrigger - Java example

Az alábbi példa egy Cosmos DB trigger-kötést mutat be a function. JSON fájlban, valamint egy olyan Java -függvényt, amely a kötést használja.The following example shows a Cosmos DB trigger binding in function.json file and a Java function that uses the binding. A függvény akkor vesz részt, ha beszúrások vagy frissítések szerepelnek a megadott adatbázisban és gyűjteményben.The function is involved when there are inserts or updates in the specified database and collection.

{
    "type": "cosmosDBTrigger",
    "name": "items",
    "direction": "in",
    "leaseCollectionName": "leases",
    "connectionStringSetting": "AzureCosmosDBConnection",
    "databaseName": "ToDoList",
    "collectionName": "Items",
    "createLeaseCollectionIfNotExists": false
}

A Java-kód itt látható:Here's the Java code:

    @FunctionName("cosmosDBMonitor")
    public void cosmosDbProcessor(
        @CosmosDBTrigger(name = "items",
            databaseName = "ToDoList",
            collectionName = "Items",
            leaseCollectionName = "leases",
            createLeaseCollectionIfNotExists = true,
            connectionStringSetting = "AzureCosmosDBConnection") String[] items,
            final ExecutionContext context ) {
                context.getLogger().info(items.length + "item(s) is/are changed.");
            }

A Java functions runtime library-ben használja @CosmosDBTrigger a Megjegyzés azon paramétereket, amelyek értéke Cosmos DBból származik.In the Java functions runtime library, use the @CosmosDBTrigger annotation on parameters whose value would come from Cosmos DB. Ezt a jegyzetet natív Java-típusokkal, szerializálói vagy NULL értékű értékekkel lehet használni opcionális<T > használatával.This annotation can be used with native Java types, POJOs, or nullable values using Optional<T>.

Trigger-példák kihagyásaSkip trigger examples

Trigger – Python-példaTrigger - Python example

Az alábbi példa egy Cosmos DB trigger kötést mutat be egy function. JSON fájlban, valamint egy olyan Python -függvényt, amely a kötést használja.The following example shows a Cosmos DB trigger binding in a function.json file and a Python function that uses the binding. A függvény naplóüzenetek ír, Cosmos DB-rekordok módosításakor.The function writes log messages when Cosmos DB records are modified.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

{
    "name": "documents",
    "type": "cosmosDBTrigger",
    "direction": "in",
    "leaseCollectionName": "leases",
    "connectionStringSetting": "<connection-app-setting>",
    "databaseName": "Tasks",
    "collectionName": "Items",
    "createLeaseCollectionIfNotExists": true
}

Itt látható a Python-kód:Here's the Python code:

    import logging
    import azure.functions as func


    def main(documents: func.DocumentList) -> str:
        if documents:
            logging.info('First document Id modified: %s', documents[0]['id'])

Trigger – C# attribútumokTrigger - C# attributes

A C#-osztálykódtárakat, használja a CosmosDBTrigger attribútum.In C# class libraries, use the CosmosDBTrigger attribute.

Az attribútum konstruktorának paramétereként meg az adatbázis és gyűjtemény nevét.The attribute's constructor takes the database name and collection name. Ezek a beállítások és más tulajdonságokat is beállíthat kapcsolatos információkért lásd: eseményindító - konfiguráció.For information about those settings and other properties that you can configure, see Trigger - configuration. Íme egy CosmosDBTrigger attribútum példa egy podpis metody:Here's a CosmosDBTrigger attribute example in a method signature:

    [FunctionName("DocumentUpdates")]
    public static void Run(
        [CosmosDBTrigger("database", "collection", ConnectionStringSetting = "myCosmosDB")]
    IReadOnlyList<Document> documents,
        ILogger log)
    {
        ...
    }

Egy teljes példa: eseményindító – C#-példa.For a complete example, see Trigger - C# example.

Eseményindító - konfigurációTrigger - configuration

A következő táblázat ismerteti a megadott kötés konfigurációs tulajdonságaiban a function.json fájlt, és a CosmosDBTrigger attribútum.The following table explains the binding configuration properties that you set in the function.json file and the CosmosDBTrigger attribute.

Function.JSON tulajdonságfunction.json property Attribútum tulajdonságaAttribute property LeírásDescription
typetype Meg kell cosmosDBTrigger.Must be set to cosmosDBTrigger.
directiondirection Meg kell in.Must be set to in. Ez a paraméter beállítása automatikusan történik, amikor az eseményindító hoz létre az Azure Portalon.This parameter is set automatically when you create the trigger in the Azure portal.
namename A függvénykód módosítása dokumentumok listájának jelölő a használt változó neve.The variable name used in function code that represents the list of documents with changes.
connectionStringSettingconnectionStringSetting ConnectionStringSettingConnectionStringSetting A figyelt Azure Cosmos DB-fiókhoz való csatlakozáshoz használt kapcsolati karakterlánc tartalmazó alkalmazásbeállítás neve.The name of an app setting that contains the connection string used to connect to the Azure Cosmos DB account being monitored.
databaseNamedatabaseName databaseNameDatabaseName A figyelt gyűjteményhez az Azure Cosmos DB-adatbázis neve.The name of the Azure Cosmos DB database with the collection being monitored.
collectionNamecollectionName collectionNameCollectionName A figyelt gyűjtemény neve.The name of the collection being monitored.
leaseConnectionStringSettingleaseConnectionStringSetting LeaseConnectionStringSettingLeaseConnectionStringSetting (Nem kötelező) A kapcsolati karakterláncot a szolgáltatásnak, amely tartalmazza a bérletek gyűjteményének tartalmazó alkalmazásbeállítás neve.(Optional) The name of an app setting that contains the connection string to the service which holds the lease collection. Ha nincs megadva, a connectionStringSetting értéket használja.When not set, the connectionStringSetting value is used. Ez a paraméter értéke a portálon a kötés létrehozásakor automatikusan.This parameter is automatically set when the binding is created in the portal. A bérletek gyűjteménye kapcsolati karakterláncára írási engedéllyel kell rendelkeznie.The connection string for the leases collection must have write permissions.
leaseDatabaseNameleaseDatabaseName LeaseDatabaseNameLeaseDatabaseName (Nem kötelező) A database csatlakoztatásához használt bérletek tárolásához használni kívánt gyűjtemény neve.(Optional) The name of the database that holds the collection used to store leases. Ha nincs megadva, az értékét a databaseName beállítást használja.When not set, the value of the databaseName setting is used. Ez a paraméter értéke a portálon a kötés létrehozásakor automatikusan.This parameter is automatically set when the binding is created in the portal.
leaseCollectionNameleaseCollectionName leaseCollectionNameLeaseCollectionName (Nem kötelező) A használt bérletek tárolásához használni kívánt gyűjtemény neve.(Optional) The name of the collection used to store leases. Ha nincs megadva, az érték leases szolgál.When not set, the value leases is used.
createLeaseCollectionIfNotExistscreateLeaseCollectionIfNotExists createLeaseCollectionIfNotExistsCreateLeaseCollectionIfNotExists (Nem kötelező) Ha a beállítása true, a bérletek gyűjteménye automatikusan létrejön, amikor még nem létezik.(Optional) When set to true, the leases collection is automatically created when it doesn't already exist. Az alapértelmezett érték false.The default value is false.
leasesCollectionThroughputleasesCollectionThroughput leasesCollectionThroughputLeasesCollectionThroughput (Nem kötelező) A Kérelemegységek rendel a bérletek gyűjteménye létrehozásakor mennyisége határozza meg.(Optional) Defines the amount of Request Units to assign when the leases collection is created. Ez a beállítás csak használhatók, amikor nem createLeaseCollectionIfNotExists értékre van állítva true.This setting is only used When createLeaseCollectionIfNotExists is set to true. Ez a paraméter értéke automatikusan, a kötés létrehozásakor a portál használatával.This parameter is automatically set when the binding is created using the portal.
leaseCollectionPrefixleaseCollectionPrefix leaseCollectionPrefixLeaseCollectionPrefix (Nem kötelező) Érték beállítása esetén azt ad hozzá egy előtagot a bérletek a bérletek gyűjteményének ennél a függvénynél, hatékonyan lehetővé teszi két különálló Azure Functions, az ugyanazon a bérletek gyűjteményének megosztása más előtagok használatával létrehozott.(Optional) When set, it adds a prefix to the leases created in the Lease collection for this Function, effectively allowing two separate Azure Functions to share the same Lease collection by using different prefixes.
feedPollDelayfeedPollDelay feedPollDelayFeedPollDelay (Nem kötelező) Ha a készlet, azt határozza meg, ezredmásodpercben, a késleltetés között egy partíciót a hírcsatorna az új módosításokat a lekérdezések összes aktuális változtatások vannak ürítve.(Optional) When set, it defines, in milliseconds, the delay in between polling a partition for new changes on the feed, after all current changes are drained. Alapértelmezés szerint 5000 (5 másodperces).Default is 5000 (5 seconds).
leaseAcquireIntervalleaseAcquireInterval leaseAcquireIntervalLeaseAcquireInterval (Nem kötelező) Érték beállítása esetén azt határozza meg, ezredmásodpercben, az időköz elindít egy feladatot a számítási, ha a partíciók lesznek elosztva a gazdagép ismert példányok között.(Optional) When set, it defines, in milliseconds, the interval to kick off a task to compute if partitions are distributed evenly among known host instances. Alapértelmezés szerint 13000 (13 másodperc).Default is 13000 (13 seconds).
leaseExpirationIntervalleaseExpirationInterval leaseExpirationIntervalLeaseExpirationInterval (Nem kötelező) Érték beállítása esetén azt határozza meg, ezredmásodpercben, az időköz, amelynek a bérlet egy bérletet, egy partíciót jelölő készül.(Optional) When set, it defines, in milliseconds, the interval for which the lease is taken on a lease representing a partition. A bérlet ezen az időtartamon belül nem újítja meg, ha azt eredményezi, hamarosan lejár, és a partíció tulajdonjogának áthelyezi egy másik példánya.If the lease is not renewed within this interval, it will cause it to expire and ownership of the partition will move to another instance. Alapértelmezés szerint 60000 (60 másodperc).Default is 60000 (60 seconds).
leaseRenewIntervalleaseRenewInterval leaseRenewIntervalLeaseRenewInterval (Nem kötelező) Érték beállítása esetén azt határozza meg, ezredmásodpercben, minden bérletek példány által jelenleg birtokolt partíciók megújítási időköz.(Optional) When set, it defines, in milliseconds, the renew interval for all leases for partitions currently held by an instance. Alapértelmezés szerint 17000 (17 másodperc).Default is 17000 (17 seconds).
checkpointFrequencycheckpointFrequency checkpointFrequencyCheckpointFrequency (Nem kötelező) Érték beállítása esetén azt határozza meg, ezredmásodpercben, a bérlet ellenőrzőpontok közötti időtartam.(Optional) When set, it defines, in milliseconds, the interval between lease checkpoints. Az alapértelmezett érték mindig az egyes függvények hívása után történik.Default is always after each Function call.
maxItemsPerInvocationmaxItemsPerInvocation maxItemsPerInvocationMaxItemsPerInvocation (Nem kötelező) Ha a beállítás, azt testreszabja egy függvény hívásához szükséges fogadott elemek maximális számát.(Optional) When set, it customizes the maximum amount of items received per Function call.
startFromBeginningstartFromBeginning StartFromBeginningStartFromBeginning Választható Ha be van állítva, a elindítja a triggert, hogy a jelenlegi időpont helyett a gyűjtemény előzményeinek elejéről olvassa be a módosításokat.(Optional) When set, it tells the Trigger to start reading changes from the beginning of the history of the collection instead of the current time. Ez csak az indítás első indításakor működik, ahogy a későbbi futtatásokban is, az ellenőrzőpontok már tárolva vannak.This only works the first time the Trigger starts, as in subsequent runs, the checkpoints are already stored. Ha úgy állítja true be ezt a beállítást, hogy a már létrehozott bérletek ne legyenek hatással.Setting this to true when there are leases already created has no effect.

Ha helyileg fejleszt, Alkalmazásbeállítások lépnek a local.settings.json fájljában.When you're developing locally, app settings go into the local.settings.json file.

Eseményindító - használatTrigger - usage

Az eseményindító van szükség egy második gyűjtemény tárolásához használt bérletek a külön partíciókban.The trigger requires a second collection that it uses to store leases over the partitions. A figyelt gyűjtemény és a gyűjtemény, amely tartalmazza a bérleteket is működnek az eseményindító elérhetőnek kell lennie.Both the collection being monitored and the collection that contains the leases must be available for the trigger to work.

Fontos

Ha több funkciók vannak konfigurálva, egy Cosmos DB-eseményindító használandó ugyanabba a gyűjteménybe, minden egyes funkciót kell egy dedikált a bérletek gyűjteményének használhatja, vagy megadhat egy másik LeaseCollectionPrefix minden függvényre.If multiple functions are configured to use a Cosmos DB trigger for the same collection, each of the functions should use a dedicated lease collection or specify a different LeaseCollectionPrefix for each function. Ellenkező esetben a függvények csak az egyik aktiválódik.Otherwise, only one of the functions will be triggered. Az előtag kapcsolatos információkért tekintse meg a konfigurációs szakasz.For information about the prefix, see the Configuration section.

Az eseményindító egy dokumentumot frissítve lett, vagy beszúrva, azt csak biztosítja-e a saját maga a dokumentum nem jelzi.The trigger doesn't indicate whether a document was updated or inserted, it just provides the document itself. Ha frissítések, és beszúr eltérően kezelésére van szüksége, beszúrási vagy frissítési időbélyegző mezők az életbe léptetésével ezt.If you need to handle updates and inserts differently, you could do that by implementing timestamp fields for insertion or update.

Input (Bemenet)Input

Az Azure Cosmos DB bemeneti kötéssel legalább egy Azure Cosmos DB-dokumentumok lekérdezésének az SQL API-t használja, és továbbítja őket a függvény a bemeneti paraméter.The Azure Cosmos DB input binding uses the SQL API to retrieve one or more Azure Cosmos DB documents and passes them to the input parameter of the function. A dokumentum azonosítója vagy lekérdezési paramétereket az eseményindítót, amely meghívja a függvényt alapján lehet meghatározni.The document ID or query parameters can be determined based on the trigger that invokes the function.

Bemenet - példákInput - examples

Példák a nyelvspecifikus, amely egyetlen dokumentum olvasása egy azonosító érték megadásával:See the language-specific examples that read a single document by specifying an ID value:

Hagyja ki a bemeneti példákSkip input examples

Bemenet - példák C#Input - C# examples

Ez a szakasz tartalmazza az alábbi példák:This section contains the following examples:

Tekintse meg a példák egy egyszerű ToDoItem típusa:The examples refer to a simple ToDoItem type:

namespace CosmosDBSamplesV2
{
    public class ToDoItem
    {
        public string Id { get; set; }
        public string Description { get; set; }
    }
}

Hagyja ki a bemeneti példákSkip input examples

Üzenetsor eseményindító, keresse meg a Azonosítót (C#) JSON-bólQueue trigger, look up ID from JSON (C#)

A következő példa bemutatja egy C#-függvény , amely egyetlen dokumentum beolvasása.The following example shows a C# function that retrieves a single document. A függvény, amely tartalmaz egy JSON-objektum egy üzenetsor által aktivált.The function is triggered by a queue message that contains a JSON object. Az üzenetsor eseményindító elemzi a JSON az nevű objektum ToDoItemLookup, keresse ki az Azonosítóját tartalmazza, amelyek.The queue trigger parses the JSON into an object named ToDoItemLookup, which contains the ID to look up. Hogy azonosító beolvasásához használt egy ToDoItem dokumentumot a megadott adatbázis és gyűjtemény.That ID is used to retrieve a ToDoItem document from the specified database and collection.

namespace CosmosDBSamplesV2
{
    public class ToDoItemLookup
    {
        public string ToDoItemId { get; set; }
    }
}
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

namespace CosmosDBSamplesV2
{
    public static class DocByIdFromJSON
    {
        [FunctionName("DocByIdFromJSON")]
        public static void Run(
            [QueueTrigger("todoqueueforlookup")] ToDoItemLookup toDoItemLookup,
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection",
                Id = "{ToDoItemId}")]ToDoItem toDoItem,
            ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed Id={toDoItemLookup?.ToDoItemId}");

            if (toDoItem == null)
            {
                log.LogInformation($"ToDo item not found");
            }
            else
            {
                log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
            }
        }
    }
}

Hagyja ki a bemeneti példákSkip input examples

HTTP-eseményindító, ID keresse meg a lekérdezési karakterláncból (C#)HTTP trigger, look up ID from query string (C#)

A következő példa bemutatja egy C#-függvény , amely egyetlen dokumentum beolvasása.The following example shows a C# function that retrieves a single document. A függvényt egy HTTP-kérelem keresse ki az azonosító megadása egy lekérdezési karakterláncot használó aktiválja.The function is triggered by an HTTP request that uses a query string to specify the ID to look up. Hogy azonosító beolvasásához használt egy ToDoItem dokumentumot a megadott adatbázis és gyűjtemény.That ID is used to retrieve a ToDoItem document from the specified database and collection.

Megjegyzés

A HTTP-lekérdezési karakterlánc paraméter megkülönbözteti a kis-és nagybetűket.The HTTP query string parameter is case-sensitive.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

namespace CosmosDBSamplesV2
{
    public static class DocByIdFromQueryString
    {
        [FunctionName("DocByIdFromQueryString")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)]
                HttpRequest req,
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection",
                Id = "{Query.id}")] ToDoItem toDoItem,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");

            if (toDoItem == null)
            {
                log.LogInformation($"ToDo item not found");
            }
            else
            {
                log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
            }
            return new OkResult();
        }
    }
}

Hagyja ki a bemeneti példákSkip input examples

HTTP eseményindító útvonal adatokból (C#) azonosító kereséseHTTP trigger, look up ID from route data (C#)

A következő példa bemutatja egy C#-függvény , amely egyetlen dokumentum beolvasása.The following example shows a C# function that retrieves a single document. A függvény akkor indul el, hogy a használt, keresse ki az azonosító megadása adatainak átirányítása a HTTP-kérelemmel történik.The function is triggered by an HTTP request that uses route data to specify the ID to look up. Hogy azonosító beolvasásához használt egy ToDoItem dokumentumot a megadott adatbázis és gyűjtemény.That ID is used to retrieve a ToDoItem document from the specified database and collection.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

namespace CosmosDBSamplesV2
{
    public static class DocByIdFromRouteData
    {
        [FunctionName("DocByIdFromRouteData")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post",
                Route = "todoitems/{id}")]HttpRequest req,
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection",
                Id = "{id}")] ToDoItem toDoItem,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");

            if (toDoItem == null)
            {
                log.LogInformation($"ToDo item not found");
            }
            else
            {
                log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
            }
            return new OkResult();
        }
    }
}

Hagyja ki a bemeneti példákSkip input examples

HTTP eseményindító útvonal adatokból, SQL-lekérdezés (C#) használatával azonosító kereséseHTTP trigger, look up ID from route data, using SqlQuery (C#)

A következő példa bemutatja egy C#-függvény , amely egyetlen dokumentum beolvasása.The following example shows a C# function that retrieves a single document. A függvény akkor indul el, hogy a használt, keresse ki az azonosító megadása adatainak átirányítása a HTTP-kérelemmel történik.The function is triggered by an HTTP request that uses route data to specify the ID to look up. Hogy azonosító beolvasásához használt egy ToDoItem dokumentumot a megadott adatbázis és gyűjtemény.That ID is used to retrieve a ToDoItem document from the specified database and collection.

A példa bemutatja, hogyan használható egy kötési kifejezés a SqlQuery paraméterben.The example shows how to use a binding expression in the SqlQuery parameter. Átadhatja az útvonal adatait a SqlQuery paraméternek, ahogy az ábrán látható, de jelenleg nem adhat meg lekérdezési karakterlánc-értékeket.You can pass route data to the SqlQuery parameter as shown, but currently you can't pass query string values.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Host;
using System.Collections.Generic;
using Microsoft.Extensions.Logging;

namespace CosmosDBSamplesV2
{
    public static class DocByIdFromRouteDataUsingSqlQuery
    {
        [FunctionName("DocByIdFromRouteDataUsingSqlQuery")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post",
                Route = "todoitems2/{id}")]HttpRequest req,
            [CosmosDB("ToDoItems", "Items",
                ConnectionStringSetting = "CosmosDBConnection",
                SqlQuery = "select * from ToDoItems r where r.id = {id}")]
                IEnumerable<ToDoItem> toDoItems,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");

            foreach (ToDoItem toDoItem in toDoItems)
            {
                log.LogInformation(toDoItem.Description);
            }
            return new OkResult();
        }
    }
}

Hagyja ki a bemeneti példákSkip input examples

HTTP-trigger, a több docs-SQL-lekérdezés (C#) használatávalHTTP trigger, get multiple docs, using SqlQuery (C#)

A következő példa bemutatja egy C#-függvény , amely dokumentumot listájának beolvasása.The following example shows a C# function that retrieves a list of documents. A függvényt egy HTTP-kérelem aktiválja.The function is triggered by an HTTP request. A lekérdezés van megadva a SqlQuery tulajdonság attribútum.The query is specified in the SqlQuery attribute property.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Host;
using System.Collections.Generic;
using Microsoft.Extensions.Logging;

namespace CosmosDBSamplesV2
{
    public static class DocsBySqlQuery
    {
        [FunctionName("DocsBySqlQuery")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)]
                HttpRequest req,
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection",
                SqlQuery = "SELECT top 2 * FROM c order by c._ts desc")]
                IEnumerable<ToDoItem> toDoItems,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");
            foreach (ToDoItem toDoItem in toDoItems)
            {
                log.LogInformation(toDoItem.Description);
            }
            return new OkResult();
        }
    }
}

Hagyja ki a bemeneti példákSkip input examples

HTTP-trigger, a több docs DocumentClient (C#) használatávalHTTP trigger, get multiple docs, using DocumentClient (C#)

A következő példa bemutatja egy C#-függvény , amely dokumentumot listájának beolvasása.The following example shows a C# function that retrieves a list of documents. A függvényt egy HTTP-kérelem aktiválja.The function is triggered by an HTTP request. A kód egy DocumentClient dokumentumok listája olvasható az Azure Cosmos DB-kötés által megadott-példány.The code uses a DocumentClient instance provided by the Azure Cosmos DB binding to read a list of documents. A DocumentClient példány is használható az írási műveletek.The DocumentClient instance could also be used for write operations.

Megjegyzés

A IDocumentClient felületet is használhatja a tesztelés megkönnyítésére.You can also use the IDocumentClient interface to make testing easier.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;
using System;
using System.Linq;
using System.Threading.Tasks;

namespace CosmosDBSamplesV2
{
    public static class DocsByUsingDocumentClient
    {
        [FunctionName("DocsByUsingDocumentClient")]
        public static async Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post",
                Route = null)]HttpRequest req,
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection")] DocumentClient client,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");

            var searchterm = req.Query["searchterm"];
            if (string.IsNullOrWhiteSpace(searchterm))
            {
                return (ActionResult)new NotFoundResult();
            }

            Uri collectionUri = UriFactory.CreateDocumentCollectionUri("ToDoItems", "Items");

            log.LogInformation($"Searching for: {searchterm}");

            IDocumentQuery<ToDoItem> query = client.CreateDocumentQuery<ToDoItem>(collectionUri)
                .Where(p => p.Description.Contains(searchterm))
                .AsDocumentQuery();

            while (query.HasMoreResults)
            {
                foreach (ToDoItem result in await query.ExecuteNextAsync())
                {
                    log.LogInformation(result.Description);
                }
            }
            return new OkResult();
        }
    }
}

Hagyja ki a bemeneti példákSkip input examples

Bemenet – C#-példaszkriptekInput - C# script examples

Ez a szakasz tartalmazza az alábbi példák:This section contains the following examples:

Tekintse meg a HTTP-eseményindító példák egy egyszerű ToDoItem típusa:The HTTP trigger examples refer to a simple ToDoItem type:

namespace CosmosDBSamplesV2
{
    public class ToDoItem
    {
        public string Id { get; set; }
        public string Description { get; set; }
    }
}

Hagyja ki a bemeneti példákSkip input examples

Üzenetsor eseményindító, (C#-szkript) karakterláncból Azonosítóját kereséseQueue trigger, look up ID from string (C# script)

Az alábbi példa bemutatja a Cosmos DB bemeneti kötéssel egy function.json fájl és a egy C#-szkriptfüggvény , amely a kötés használja.The following example shows a Cosmos DB input binding in a function.json file and a C# script function that uses the binding. A függvény beolvassa az egyetlen dokumentum, és frissíti a dokumentum szöveges érték.The function reads a single document and updates the document's text value.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

{
    "name": "inputDocument",
    "type": "cosmosDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "id" : "{queueTrigger}",
    "partitionKey": "{partition key value}",
    "connectionStringSetting": "MyAccount_COSMOSDB",
    "direction": "in"
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

Íme a C#-szkriptkódot:Here's the C# script code:

    using System;

    // Change input document contents using Azure Cosmos DB input binding
    public static void Run(string myQueueItem, dynamic inputDocument)
    {
      inputDocument.text = "This has changed.";
    }

Hagyja ki a bemeneti példákSkip input examples

Várólista-eseményindító, majd a több docs-SQL-lekérdezés (C#-szkript) használatávalQueue trigger, get multiple docs, using SqlQuery (C# script)

Az alábbi példa bemutatja egy Azure Cosmos DB bemeneti kötéssel a egy function.json fájl és a egy C#-szkriptfüggvény , amely a kötés használja.The following example shows an Azure Cosmos DB input binding in a function.json file and a C# script function that uses the binding. A függvény egy SQL-lekérdezést, egy üzenetsor eseményindító segítségével testre szabhatja a lekérdezési paraméterek által megadott több dokumentumot kérdezi le.The function retrieves multiple documents specified by a SQL query, using a queue trigger to customize the query parameters.

Az üzenetsor eseményindító biztosít egy paraméter departmentId.The queue trigger provides a parameter departmentId. Az üzenetsorbeli üzenet { "departmentId" : "Finance" } adna vissza, a pénzügyi részleg összes rekordja.A queue message of { "departmentId" : "Finance" } would return all records for the finance department.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

{
    "name": "documents",
    "type": "cosmosDB",
    "direction": "in",
    "databaseName": "MyDb",
    "collectionName": "MyCollection",
    "sqlQuery": "SELECT * from c where c.departmentId = {departmentId}",
    "connectionStringSetting": "CosmosDBConnection"
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

Íme a C#-szkriptkódot:Here's the C# script code:

    public static void Run(QueuePayload myQueueItem, IEnumerable<dynamic> documents)
    {
        foreach (var doc in documents)
        {
            // operate on each document
        }
    }

    public class QueuePayload
    {
        public string departmentId { get; set; }
    }

Hagyja ki a bemeneti példákSkip input examples

HTTP-eseményindító, ID keresse meg a lekérdezési karakterláncból (C#-szkript)HTTP trigger, look up ID from query string (C# script)

A következő példa bemutatja egy C#-szkriptfüggvény , amely egyetlen dokumentum beolvasása.The following example shows a C# script function that retrieves a single document. A függvényt egy HTTP-kérelem keresse ki az azonosító megadása egy lekérdezési karakterláncot használó aktiválja.The function is triggered by an HTTP request that uses a query string to specify the ID to look up. Hogy azonosító beolvasásához használt egy ToDoItem dokumentumot a megadott adatbázis és gyűjtemény.That ID is used to retrieve a ToDoItem document from the specified database and collection.

Íme a function.json fájlt:Here's the function.json file:

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "Id": "{Query.id}"
    }
  ],
  "disabled": false
}

Íme a C#-szkriptkódot:Here's the C# script code:

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

public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    if (toDoItem == null)
    {
         log.LogInformation($"ToDo item not found");
    }
    else
    {
        log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Hagyja ki a bemeneti példákSkip input examples

HTTP eseményindító útvonal adatokból (C#-szkript) azonosító kereséseHTTP trigger, look up ID from route data (C# script)

A következő példa bemutatja egy C#-szkriptfüggvény , amely egyetlen dokumentum beolvasása.The following example shows a C# script function that retrieves a single document. A függvény akkor indul el, hogy a használt, keresse ki az azonosító megadása adatainak átirányítása a HTTP-kérelemmel történik.The function is triggered by an HTTP request that uses route data to specify the ID to look up. Hogy azonosító beolvasásához használt egy ToDoItem dokumentumot a megadott adatbázis és gyűjtemény.That ID is used to retrieve a ToDoItem document from the specified database and collection.

Íme a function.json fájlt:Here's the function.json file:

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ],
      "route":"todoitems/{id}"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "Id": "{id}"
    }
  ],
  "disabled": false
}

Íme a C#-szkriptkódot:Here's the C# script code:

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

public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    if (toDoItem == null)
    {
         log.LogInformation($"ToDo item not found");
    }
    else
    {
        log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Hagyja ki a bemeneti példákSkip input examples

HTTP-trigger, a több docs-SQL-lekérdezés (C#-szkript) használatávalHTTP trigger, get multiple docs, using SqlQuery (C# script)

A következő példa bemutatja egy C#-szkriptfüggvény , amely dokumentumot listájának beolvasása.The following example shows a C# script function that retrieves a list of documents. A függvényt egy HTTP-kérelem aktiválja.The function is triggered by an HTTP request. A lekérdezés van megadva a SqlQuery tulajdonság attribútum.The query is specified in the SqlQuery attribute property.

Íme a function.json fájlt:Here's the function.json file:

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItems",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "sqlQuery": "SELECT top 2 * FROM c order by c._ts desc"
    }
  ],
  "disabled": false
}

Íme a C#-szkriptkódot:Here's the C# script code:

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

public static HttpResponseMessage Run(HttpRequestMessage req, IEnumerable<ToDoItem> toDoItems, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    foreach (ToDoItem toDoItem in toDoItems)
    {
        log.LogInformation(toDoItem.Description);
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Hagyja ki a bemeneti példákSkip input examples

HTTP-trigger, a több docs DocumentClient (C#-szkript) használatávalHTTP trigger, get multiple docs, using DocumentClient (C# script)

A következő példa bemutatja egy C#-szkriptfüggvény , amely dokumentumot listájának beolvasása.The following example shows a C# script function that retrieves a list of documents. A függvényt egy HTTP-kérelem aktiválja.The function is triggered by an HTTP request. A kód egy DocumentClient dokumentumok listája olvasható az Azure Cosmos DB-kötés által megadott-példány.The code uses a DocumentClient instance provided by the Azure Cosmos DB binding to read a list of documents. A DocumentClient példány is használható az írási műveletek.The DocumentClient instance could also be used for write operations.

Íme a function.json fájlt:Here's the function.json file:

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "client",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "inout"
    }
  ],
  "disabled": false
}

Íme a C#-szkriptkódot:Here's the C# script code:

#r "Microsoft.Azure.Documents.Client"

using System.Net;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Microsoft.Extensions.Logging;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, DocumentClient client, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    Uri collectionUri = UriFactory.CreateDocumentCollectionUri("ToDoItems", "Items");
    string searchterm = req.GetQueryNameValuePairs()
        .FirstOrDefault(q => string.Compare(q.Key, "searchterm", true) == 0)
        .Value;

    if (searchterm == null)
    {
        return req.CreateResponse(HttpStatusCode.NotFound);
    }

    log.LogInformation($"Searching for word: {searchterm} using Uri: {collectionUri.ToString()}");
    IDocumentQuery<ToDoItem> query = client.CreateDocumentQuery<ToDoItem>(collectionUri)
        .Where(p => p.Description.Contains(searchterm))
        .AsDocumentQuery();

    while (query.HasMoreResults)
    {
        foreach (ToDoItem result in await query.ExecuteNextAsync())
        {
            log.LogInformation(result.Description);
        }
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Hagyja ki a bemeneti példákSkip input examples

Bemenet - JavaScript-példákInput - JavaScript examples

Ez a szakasz az alábbi példákat tartalmazza, amelyek egyetlen dokumentumot olvasnak be a különböző forrásokból származó azonosító érték megadásával:This section contains the following examples that read a single document by specifying an ID value from various sources:

Hagyja ki a bemeneti példákSkip input examples

Üzenetsor eseményindító, keresse meg a-azonosító a JSON (JavaScript)Queue trigger, look up ID from JSON (JavaScript)

Az alábbi példa bemutatja a Cosmos DB bemeneti kötéssel egy function.json fájl és a egy JavaScript-függvény , amely a kötés használja.The following example shows a Cosmos DB input binding in a function.json file and a JavaScript function that uses the binding. A függvény beolvassa az egyetlen dokumentum, és frissíti a dokumentum szöveges érték.The function reads a single document and updates the document's text value.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

{
    "name": "inputDocumentIn",
    "type": "cosmosDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "id" : "{queueTrigger_payload_property}",
    "partitionKey": "{queueTrigger_payload_property}",
    "connectionStringSetting": "MyAccount_COSMOSDB",
    "direction": "in"
},
{
    "name": "inputDocumentOut",
    "type": "cosmosDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "createIfNotExists": false,
    "partitionKey": "{queueTrigger_payload_property}",
    "connectionStringSetting": "MyAccount_COSMOSDB",
    "direction": "out"
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

A következő JavaScript-kódot:Here's the JavaScript code:

    // Change input document contents using Azure Cosmos DB input binding, using context.bindings.inputDocumentOut
    module.exports = function (context) {
    context.bindings.inputDocumentOut = context.bindings.inputDocumentIn;
    context.bindings.inputDocumentOut.text = "This was updated!";
    context.done();
    };

Hagyja ki a bemeneti példákSkip input examples

HTTP-eseményindító, ID keresse meg a lekérdezési karakterláncból (JavaScript)HTTP trigger, look up ID from query string (JavaScript)

A következő példa bemutatja egy JavaScript-függvény , amely egyetlen dokumentum beolvasása.The following example shows a JavaScript function that retrieves a single document. A függvényt egy HTTP-kérelem keresse ki az azonosító megadása egy lekérdezési karakterláncot használó aktiválja.The function is triggered by an HTTP request that uses a query string to specify the ID to look up. Hogy azonosító beolvasásához használt egy ToDoItem dokumentumot a megadott adatbázis és gyűjtemény.That ID is used to retrieve a ToDoItem document from the specified database and collection.

Íme a function.json fájlt:Here's the function.json file:

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "Id": "{Query.id}"
    }
  ],
  "disabled": false
}

A következő JavaScript-kódot:Here's the JavaScript code:

module.exports = function (context, req, toDoItem) {
    context.log('JavaScript queue trigger function processed work item');
    if (!toDoItem)
    {
        context.log("ToDo item not found");
    }
    else
    {
        context.log("Found ToDo item, Description=" + toDoItem.Description);
    }

    context.done();
};

Hagyja ki a bemeneti példákSkip input examples

HTTP eseményindító útvonal adatokból (JavaScript-) azonosító kereséseHTTP trigger, look up ID from route data (JavaScript)

A következő példa bemutatja egy JavaScript-függvény , amely egyetlen dokumentum beolvasása.The following example shows a JavaScript function that retrieves a single document. A függvényt egy HTTP-kérelem keresse ki az azonosító megadása egy lekérdezési karakterláncot használó aktiválja.The function is triggered by an HTTP request that uses a query string to specify the ID to look up. Hogy azonosító beolvasásához használt egy ToDoItem dokumentumot a megadott adatbázis és gyűjtemény.That ID is used to retrieve a ToDoItem document from the specified database and collection.

Íme a function.json fájlt:Here's the function.json file:

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ],
      "route":"todoitems/{id}"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "in",
      "Id": "{id}"
    }
  ],
  "disabled": false
}

A következő JavaScript-kódot:Here's the JavaScript code:

module.exports = function (context, req, toDoItem) {
    context.log('JavaScript queue trigger function processed work item');
    if (!toDoItem)
    {
        context.log("ToDo item not found");
    }
    else
    {
        context.log("Found ToDo item, Description=" + toDoItem.Description);
    }

    context.done();
};

Hagyja ki a bemeneti példákSkip input examples

Várólista-eseményindító, majd a több docs-SQL-lekérdezés (JavaScript) használatávalQueue trigger, get multiple docs, using SqlQuery (JavaScript)

Az alábbi példa bemutatja egy Azure Cosmos DB bemeneti kötéssel a egy function.json fájl és a egy JavaScript-függvény , amely a kötés használja.The following example shows an Azure Cosmos DB input binding in a function.json file and a JavaScript function that uses the binding. A függvény egy SQL-lekérdezést, egy üzenetsor eseményindító segítségével testre szabhatja a lekérdezési paraméterek által megadott több dokumentumot kérdezi le.The function retrieves multiple documents specified by a SQL query, using a queue trigger to customize the query parameters.

Az üzenetsor eseményindító biztosít egy paraméter departmentId.The queue trigger provides a parameter departmentId. Az üzenetsorbeli üzenet { "departmentId" : "Finance" } adna vissza, a pénzügyi részleg összes rekordja.A queue message of { "departmentId" : "Finance" } would return all records for the finance department.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

{
    "name": "documents",
    "type": "cosmosDB",
    "direction": "in",
    "databaseName": "MyDb",
    "collectionName": "MyCollection",
    "sqlQuery": "SELECT * from c where c.departmentId = {departmentId}",
    "connectionStringSetting": "CosmosDBConnection"
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

A következő JavaScript-kódot:Here's the JavaScript code:

    module.exports = function (context, input) {
        var documents = context.bindings.documents;
        for (var i = 0; i < documents.length; i++) {
            var document = documents[i];
            // operate on each document
        }
        context.done();
    };

Hagyja ki a bemeneti példákSkip input examples

Bemenet – Python-példákInput - Python examples

Ez a szakasz az alábbi példákat tartalmazza, amelyek egyetlen dokumentumot olvasnak be a különböző forrásokból származó azonosító érték megadásával:This section contains the following examples that read a single document by specifying an ID value from various sources:

Hagyja ki a bemeneti példákSkip input examples

Üzenetsor-trigger, Keresés azonosító a JSON-ből (Python)Queue trigger, look up ID from JSON (Python)

Az alábbi példa egy Cosmos DB bemeneti kötést mutat be egy function. JSON fájlban, valamint egy olyan Python -függvényt, amely a kötést használja.The following example shows a Cosmos DB input binding in a function.json file and a Python function that uses the binding. A függvény beolvassa az egyetlen dokumentum, és frissíti a dokumentum szöveges érték.The function reads a single document and updates the document's text value.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

{
    "name": "documents",
    "type": "cosmosDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "id" : "{queueTrigger_payload_property}",
    "partitionKey": "{queueTrigger_payload_property}",
    "connectionStringSetting": "MyAccount_COSMOSDB",
    "direction": "in"
},
{
    "name": "$return",
    "type": "cosmosDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "createIfNotExists": false,
    "partitionKey": "{queueTrigger_payload_property}",
    "connectionStringSetting": "MyAccount_COSMOSDB",
    "direction": "out"
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

Itt látható a Python-kód:Here's the Python code:

import azure.functions as func


def main(queuemsg: func.QueueMessage, documents: func.DocumentList) -> func.Document:
    if documents:
        document = documents[0]
        document['text'] = 'This was updated!'
        return document

Hagyja ki a bemeneti példákSkip input examples

HTTP-trigger, Keresés azonosító lekérdezési karakterláncból (Python)HTTP trigger, look up ID from query string (Python)

Az alábbi példa egy olyan Python -függvényt mutat be, amely egyetlen dokumentumot kér le.The following example shows a Python function that retrieves a single document. A függvényt egy HTTP-kérelem keresse ki az azonosító megadása egy lekérdezési karakterláncot használó aktiválja.The function is triggered by an HTTP request that uses a query string to specify the ID to look up. Hogy azonosító beolvasásához használt egy ToDoItem dokumentumot a megadott adatbázis és gyűjtemény.That ID is used to retrieve a ToDoItem document from the specified database and collection.

Íme a function.json fájlt:Here's the function.json file:

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "todoitems",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "Id": "{Query.id}"
    }
  ],
  "disabled": true,
  "scriptFile": "__init__.py"
}

Itt látható a Python-kód:Here's the Python code:

import logging
import azure.functions as func


def main(req: func.HttpRequest, todoitems: func.DocumentList) -> str:
    if not todoitems:
        logging.warning("ToDo item not found")
    else:
        logging.info("Found ToDo item, Description=%s",
                     todoitems[0]['description'])

    return 'OK'

Hagyja ki a bemeneti példákSkip input examples

HTTP-trigger, azonosító megkeresése az útválasztási adatokból (Python)HTTP trigger, look up ID from route data (Python)

Az alábbi példa egy olyan Python -függvényt mutat be, amely egyetlen dokumentumot kér le.The following example shows a Python function that retrieves a single document. A függvényt egy HTTP-kérelem keresse ki az azonosító megadása egy lekérdezési karakterláncot használó aktiválja.The function is triggered by an HTTP request that uses a query string to specify the ID to look up. Hogy azonosító beolvasásához használt egy ToDoItem dokumentumot a megadott adatbázis és gyűjtemény.That ID is used to retrieve a ToDoItem document from the specified database and collection.

Íme a function.json fájlt:Here's the function.json file:

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ],
      "route":"todoitems/{id}"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "todoitems",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "in",
      "Id": "{id}"
    }
  ],
  "disabled": false,
  "scriptFile": "__init__.py"
}

Itt látható a Python-kód:Here's the Python code:

import logging
import azure.functions as func


def main(req: func.HttpRequest, todoitems: func.DocumentList) -> str:
    if not todoitems:
        logging.warning("ToDo item not found")
    else:
        logging.info("Found ToDo item, Description=%s",
                     todoitems[0]['description'])
    return 'OK'

Hagyja ki a bemeneti példákSkip input examples

Üzenetsor-trigger, több dokumentum beolvasása a SqlQuery (Python) használatávalQueue trigger, get multiple docs, using SqlQuery (Python)

Az alábbi példa egy Azure Cosmos DB bemeneti kötést mutat be egy function. JSON fájlban, valamint egy olyan Python -függvényt, amely a kötést használja.The following example shows an Azure Cosmos DB input binding in a function.json file and a Python function that uses the binding. A függvény egy SQL-lekérdezést, egy üzenetsor eseményindító segítségével testre szabhatja a lekérdezési paraméterek által megadott több dokumentumot kérdezi le.The function retrieves multiple documents specified by a SQL query, using a queue trigger to customize the query parameters.

Az üzenetsor eseményindító biztosít egy paraméter departmentId.The queue trigger provides a parameter departmentId. Az üzenetsorbeli üzenet { "departmentId" : "Finance" } adna vissza, a pénzügyi részleg összes rekordja.A queue message of { "departmentId" : "Finance" } would return all records for the finance department.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

{
    "name": "documents",
    "type": "cosmosDB",
    "direction": "in",
    "databaseName": "MyDb",
    "collectionName": "MyCollection",
    "sqlQuery": "SELECT * from c where c.departmentId = {departmentId}",
    "connectionStringSetting": "CosmosDBConnection"
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

Itt látható a Python-kód:Here's the Python code:

import azure.functions as func

def main(queuemsg: func.QueueMessage, documents: func.DocumentList):
    for document in documents:
        # operate on each document

Hagyja ki a bemeneti példákSkip input examples

Bemenet - F# példákInput - F# examples

Az alábbi példa bemutatja a Cosmos DB bemeneti kötéssel egy function.json fájl és a egy F# függvény , amely a kötés használja.The following example shows a Cosmos DB input binding in a function.json file and a F# function that uses the binding. A függvény beolvassa az egyetlen dokumentum, és frissíti a dokumentum szöveges érték.The function reads a single document and updates the document's text value.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

{
    "name": "inputDocument",
    "type": "cosmosDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "id" : "{queueTrigger}",
    "connectionStringSetting": "MyAccount_COSMOSDB",
    "direction": "in"
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

Íme a F# kódot:Here's the F# code:

    (* Change input document contents using Azure Cosmos DB input binding *)
    open FSharp.Interop.Dynamic
    let Run(myQueueItem: string, inputDocument: obj) =
    inputDocument?text <- "This has changed."

Ebben a példában van szükség egy project.json fájlt, amely meghatározza a FSharp.Interop.Dynamic és Dynamitey NuGet-függőségek:This example requires a project.json file that specifies the FSharp.Interop.Dynamic and Dynamitey NuGet dependencies:

{
    "frameworks": {
        "net46": {
            "dependencies": {
                "Dynamitey": "1.0.2",
                "FSharp.Interop.Dynamic": "3.0.0"
            }
        }
    }
}

Hozzáadása egy project.json fájlt F# felügyeleti csomag.To add a project.json file, see F# package management.

Bevitel – Java-példákInput - Java examples

Ez a szakasz tartalmazza az alábbi példák:This section contains the following examples:

Tekintse meg a példák egy egyszerű ToDoItem típusa:The examples refer to a simple ToDoItem type:

public class ToDoItem {

  private String id;
  private String description;

  public String getId() {
    return id;
  }

  public String getDescription() {
    return description;
  }

  @Override
  public String toString() {
    return "ToDoItem={id=" + id + ",description=" + description + "}";
  }
}

HTTP-trigger, Keresés azonosító lekérdezési karakterláncból – karakterlánc-paraméter (Java)HTTP trigger, look up ID from query string - String parameter (Java)

Az alábbi példa egy Java-függvényt mutat be, amely egyetlen dokumentumot kér le.The following example shows a Java function that retrieves a single document. A függvényt egy olyan HTTP-kérelem indítja el, amely egy lekérdezési karakterláncot használ a megkeresni kívánt azonosító megadásához.The function is triggered by a HTTP request that uses a query string to specify the ID to look up. Ez az azonosító a megadott adatbázisból és gyűjteményből származó dokumentum lekérésére szolgál karakterlánc formájában.That ID is used to retrieve a document from the specified database and collection, in String form.

public class DocByIdFromQueryString {

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

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());
        context.getLogger().info("String from the database is " + (item.isPresent() ? item.get() : null));

        // Convert and display
        if (!item.isPresent()) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                          .body("Document not found.")
                          .build();
        }
        else {
            // return JSON from Cosmos. Alternatively, we can parse the JSON string
            // and return an enriched JSON object.
            return request.createResponseBuilder(HttpStatus.OK)
                          .header("Content-Type", "application/json")
                          .body(item.get())
                          .build();
        }
    }
}

A Java functions runtime library-ben használja @CosmosDBInput a megjegyzések a függvény azon paramétereit, amelyek értéke Cosmos DBból származik.In the Java functions runtime library, use the @CosmosDBInput annotation on function parameters whose value would come from Cosmos DB. Ezt a jegyzetet natív Java-típusokkal, szerializálói vagy NULL értékű értékekkel lehet használni opcionális<T > használatával.This annotation can be used with native Java types, POJOs, or nullable values using Optional<T>.

HTTP-trigger, Keresés azonosító lekérdezési karakterláncból – POJO paraméter (Java)HTTP trigger, look up ID from query string - POJO parameter (Java)

Az alábbi példa egy Java-függvényt mutat be, amely egyetlen dokumentumot kér le.The following example shows a Java function that retrieves a single document. A függvényt egy olyan HTTP-kérelem indítja el, amely egy lekérdezési karakterláncot használ a megkeresni kívánt azonosító megadásához.The function is triggered by a HTTP request that uses a query string to specify the ID to look up. Ez az azonosító a megadott adatbázisból és gyűjteményből származó dokumentumok beolvasására szolgál.That ID is used to retrieve a document from the specified database and collection. A dokumentumot ezután a rendszer a ToDoItem korábban létrehozott POJO egy példányára konvertálja, és argumentumként adta át a függvénynek.The document is then converted to an instance of the ToDoItem POJO previously created, and passed as an argument to the function.

public class DocByIdFromQueryStringPojo {

    @FunctionName("DocByIdFromQueryStringPojo")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req",
              methods = {HttpMethod.GET, HttpMethod.POST},
              authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<String>> request,
            @CosmosDBInput(name = "database",
              databaseName = "ToDoList",
              collectionName = "Items",
              id = "{Query.id}",
              partitionKey = "{Query.id}",
              connectionStringSetting = "Cosmos_DB_Connection_String")
            ToDoItem item,
            final ExecutionContext context) {

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());
        context.getLogger().info("Item from the database is " + item);

        // Convert and display
        if (item == null) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                          .body("Document not found.")
                          .build();
        }
        else {
            return request.createResponseBuilder(HttpStatus.OK)
                          .header("Content-Type", "application/json")
                          .body(item)
                          .build();
        }
    }
}

HTTP-trigger, azonosító megkeresése az útvonal adatainak (Java) alapjánHTTP trigger, look up ID from route data (Java)

Az alábbi példa egy Java-függvényt mutat be, amely egyetlen dokumentumot kér le.The following example shows a Java function that retrieves a single document. A függvényt egy Route paramétert használó HTTP-kérelem indítja el, amely megadja a megkeresni kívánt azonosítót.The function is triggered by a HTTP request that uses a route parameter to specify the ID to look up. Ez az azonosító a megadott adatbázisból és gyűjteményből Optional<String>származó dokumentumok beolvasására szolgál.That ID is used to retrieve a document from the specified database and collection, returning it as an Optional<String>.

public class DocByIdFromRoute {

    @FunctionName("DocByIdFromRoute")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req",
              methods = {HttpMethod.GET, HttpMethod.POST},
              authLevel = AuthorizationLevel.ANONYMOUS,
              route = "todoitems/{id}")
            HttpRequestMessage<Optional<String>> request,
            @CosmosDBInput(name = "database",
              databaseName = "ToDoList",
              collectionName = "Items",
              id = "{id}",
              partitionKey = "{id}",
              connectionStringSetting = "Cosmos_DB_Connection_String")
            Optional<String> item,
            final ExecutionContext context) {

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());
        context.getLogger().info("String from the database is " + (item.isPresent() ? item.get() : null));

        // Convert and display
        if (!item.isPresent()) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                          .body("Document not found.")
                          .build();
        }
        else {
            // return JSON from Cosmos. Alternatively, we can parse the JSON string
            // and return an enriched JSON object.
            return request.createResponseBuilder(HttpStatus.OK)
                          .header("Content-Type", "application/json")
                          .body(item.get())
                          .build();
        }
    }
}

HTTP-trigger, keresés az útvonal adatai alapján, SqlQuery (Java) használatávalHTTP trigger, look up ID from route data, using SqlQuery (Java)

Az alábbi példa egy Java-függvényt mutat be, amely egyetlen dokumentumot kér le.The following example shows a Java function that retrieves a single document. A függvényt egy Route paramétert használó HTTP-kérelem indítja el, amely megadja a megkeresni kívánt azonosítót.The function is triggered by a HTTP request that uses a route parameter to specify the ID to look up. Ez az azonosító a megadott adatbázisból és gyűjteményből származó dokumentum lekérésére, az eredményhalmaz a ToDoItem[]-re való átalakítására szolgál, mivel a lekérdezési feltételektől függően sok dokumentum visszaadásra kerül.That ID is used to retrieve a document from the specified database and collection, converting the result set to a ToDoItem[], since many documents may be returned, depending on the query criteria.

public class DocByIdFromRouteSqlQuery {

    @FunctionName("DocByIdFromRouteSqlQuery")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req",
              methods = {HttpMethod.GET, HttpMethod.POST},
              authLevel = AuthorizationLevel.ANONYMOUS,
              route = "todoitems2/{id}")
            HttpRequestMessage<Optional<String>> request,
            @CosmosDBInput(name = "database",
              databaseName = "ToDoList",
              collectionName = "Items",
              sqlQuery = "select * from Items r where r.id = {id}",
              connectionStringSetting = "Cosmos_DB_Connection_String")
            ToDoItem[] item,
            final ExecutionContext context) {

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());
        context.getLogger().info("Items from the database are " + item);

        // Convert and display
        if (item == null) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                          .body("Document not found.")
                          .build();
        }
        else {
            return request.createResponseBuilder(HttpStatus.OK)
                          .header("Content-Type", "application/json")
                          .body(item)
                          .build();
        }
    }
}

HTTP-trigger, több dokumentum beolvasása az útvonal adataiból a SqlQuery (Java) használatávalHTTP trigger, get multiple docs from route data, using SqlQuery (Java)

Az alábbi példa egy Java-függvényt mutat be, amely több dokumentumot is mutat.The following example shows a Java function that multiple documents. A függvényt egy Route paramétert desc használó HTTP-kérelem indítja el, amely megadja a description mezőben keresendő karakterláncot.The function is triggered by a HTTP request that uses a route parameter desc to specify the string to search for in the description field. A keresési kifejezés a megadott adatbázisból és gyűjteményből származó dokumentumok gyűjteményének lekérésére, ToDoItem[] valamint az eredményhalmaz és a függvény argumentumként való átadására szolgál.The search term is used to retrieve a collection of documents from the specified database and collection, converting the result set to a ToDoItem[] and passing it as an argument to the function.

public class DocsFromRouteSqlQuery {

    @FunctionName("DocsFromRouteSqlQuery")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req",
              methods = {HttpMethod.GET},
              authLevel = AuthorizationLevel.ANONYMOUS,
              route = "todoitems3/{desc}")
            HttpRequestMessage<Optional<String>> request,
            @CosmosDBInput(name = "database",
              databaseName = "ToDoList",
              collectionName = "Items",
              sqlQuery = "select * from Items r where contains(r.description, {desc})",
              connectionStringSetting = "Cosmos_DB_Connection_String")
            ToDoItem[] items,
            final ExecutionContext context) {

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());
        context.getLogger().info("Number of items from the database is " + (items == null ? 0 : items.length));

        // Convert and display
        if (items == null) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                          .body("No documents found.")
                          .build();
        }
        else {
            return request.createResponseBuilder(HttpStatus.OK)
                          .header("Content-Type", "application/json")
                          .body(items)
                          .build();
        }
    }
}

Bemenet - attribútumokInput - attributes

Az C# osztályok könyvtáraibanhasználja a CosmosDB attribútumot.In C# class libraries, use the CosmosDB attribute.

Az attribútum konstruktorának paramétereként meg az adatbázis és gyűjtemény nevét.The attribute's constructor takes the database name and collection name. Ezek a beállítások és más tulajdonságokat is beállíthat kapcsolatos információkért lásd: az alábbi konfigurációs szakaszban.For information about those settings and other properties that you can configure, see the following configuration section.

Bemenet - konfigurációInput - configuration

A következő táblázat ismerteti a megadott kötés konfigurációs tulajdonságaiban a function.json fájlt, és a CosmosDB attribútum.The following table explains the binding configuration properties that you set in the function.json file and the CosmosDB attribute.

Function.JSON tulajdonságfunction.json property Attribútum tulajdonságaAttribute property LeírásDescription
typetype Meg kell cosmosDB.Must be set to cosmosDB.
directiondirection Meg kell in.Must be set to in.
namename A kötési paraméter, amely a dokumentumot, a függvény neve.Name of the binding parameter that represents the document in the function.
databaseNamedatabaseName databaseNameDatabaseName A dokumentum tartalmazó adatbázis.The database containing the document.
collectionNamecollectionName collectionNameCollectionName A gyűjtemény, amely tartalmazza a dokumentum neve.The name of the collection that contains the document.
idid AzonosítóId A lekérdezni kívánt a dokumentum Azonosítóját.The ID of the document to retrieve. Ez a tulajdonság támogatja kötési kifejezésekben.This property supports binding expressions. Ne állítsa mind a azonosító és SQL-lekérdezés tulajdonságait.Don't set both the id and sqlQuery properties. Ha nem állít be egy, a rendszer lekéri a teljes gyűjteményt.If you don't set either one, the entire collection is retrieved.
sqlQuerysqlQuery SqlQuerySqlQuery Egy Azure Cosmos DB SQL-lekérdezés több dokumentumok használt.An Azure Cosmos DB SQL query used for retrieving multiple documents. A tulajdonság támogatja a futtatókörnyezet kötések, mint ebben a példában: SELECT * FROM c where c.departmentId = {departmentId}.The property supports runtime bindings, as in this example: SELECT * FROM c where c.departmentId = {departmentId}. Ne állítsa mind a azonosító és SQL-lekérdezés tulajdonságait.Don't set both the id and sqlQuery properties. Ha nem állít be egy, a rendszer lekéri a teljes gyűjteményt.If you don't set either one, the entire collection is retrieved.
connectionStringSettingconnectionStringSetting ConnectionStringSettingConnectionStringSetting Az Azure Cosmos DB kapcsolati sztringjét tartalmazó alkalmazásbeállítás neve.The name of the app setting containing your Azure Cosmos DB connection string.
partitionKeypartitionKey PartitionKeyPartitionKey Megadja a partíciós kulcs értékét a kereséshez.Specifies the partition key value for the lookup. Előfordulhat, hogy tartalmazza a kötési paramétereket.May include binding parameters.

Ha helyileg fejleszt, Alkalmazásbeállítások lépnek a local.settings.json fájljában.When you're developing locally, app settings go into the local.settings.json file.

Bemenet - használatInput - usage

A C# és F# funkciók, ha a függvény kilép sikeres, a bemeneti dokumentum nevű bemeneti keresztül végzett módosítások automatikusan megmaradnak a paramétereket.In C# and F# functions, when the function exits successfully, any changes made to the input document via named input parameters are automatically persisted.

JavaScript-függvények, a frissítések nem automatikusan történik függvény kilépéskor.In JavaScript functions, updates are not made automatically upon function exit. Ehelyett használjon context.bindings.<documentName>In és context.bindings.<documentName>Out frissítéséhez.Instead, use context.bindings.<documentName>In and context.bindings.<documentName>Out to make updates. Tekintse meg a JavaScript példáját.See the JavaScript example.

OutputOutput

Az Azure Cosmos DB kimeneti kötés lehetővé teszi, hogy egy Azure Cosmos DB-adatbázishoz az SQL API használatával írhat egy új dokumentumot.The Azure Cosmos DB output binding lets you write a new document to an Azure Cosmos DB database using the SQL API.

Kimenet – példaOutput - examples

A nyelvspecifikus példa látható:See the language-specific examples:

Lásd még a bemeneti példa használó DocumentClient.See also the input example that uses DocumentClient.

Hagyja ki a kimeneti példaSkip output examples

Kimenete – C# példákOutput - C# examples

Ez a szakasz tartalmazza az alábbi példák:This section contains the following examples:

  • Üzenetsor eseményindító írási egy dokumentumotQueue trigger, write one doc
  • Üzenetsor eseményindító írási docs IAsyncCollector használatávalQueue trigger, write docs using IAsyncCollector

Tekintse meg a példák egy egyszerű ToDoItem típusa:The examples refer to a simple ToDoItem type:

namespace CosmosDBSamplesV2
{
    public class ToDoItem
    {
        public string Id { get; set; }
        public string Description { get; set; }
    }
}

Hagyja ki a kimeneti példaSkip output examples

Üzenetsor eseményindító írási egy dokumentumot (C#)Queue trigger, write one doc (C#)

A következő példa bemutatja egy C#-függvény egy dokumentumot, amely hozzáad egy adatbázishoz, message Queue storage-ból a megadott adatok használatával.The following example shows a C# function that adds a document to a database, using data provided in message from Queue storage.

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;
using System;

namespace CosmosDBSamplesV2
{
    public static class WriteOneDoc
    {
        [FunctionName("WriteOneDoc")]
        public static void Run(
            [QueueTrigger("todoqueueforwrite")] string queueMessage,
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection")]out dynamic document,
            ILogger log)
        {
            document = new { Description = queueMessage, id = Guid.NewGuid() };

            log.LogInformation($"C# Queue trigger function inserted one row");
            log.LogInformation($"Description={queueMessage}");
        }
    }
}

Hagyja ki a kimeneti példaSkip output examples

Üzenetsor eseményindító írási docs IAsyncCollector (C#) használatávalQueue trigger, write docs using IAsyncCollector (C#)

A következő példa bemutatja egy C#-függvény dokumentumok gyűjteménye, amely ad egy adatbázishoz, az adatok JSON üzenetsori üzenet megadott.The following example shows a C# function that adds a collection of documents to a database, using data provided in a queue message JSON.

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

namespace CosmosDBSamplesV2
{
    public static class WriteDocsIAsyncCollector
    {
        [FunctionName("WriteDocsIAsyncCollector")]
        public static async Task Run(
            [QueueTrigger("todoqueueforwritemulti")] ToDoItem[] toDoItemsIn,
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection")]
                IAsyncCollector<ToDoItem> toDoItemsOut,
            ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

            foreach (ToDoItem toDoItem in toDoItemsIn)
            {
                log.LogInformation($"Description={toDoItem.Description}");
                await toDoItemsOut.AddAsync(toDoItem);
            }
        }
    }
}

Hagyja ki a kimeneti példaSkip output examples

Kimenet – C#-példaszkriptekOutput - C# script examples

Ez a szakasz tartalmazza az alábbi példák:This section contains the following examples:

  • Üzenetsor eseményindító írási egy dokumentumotQueue trigger, write one doc
  • Üzenetsor eseményindító írási docs IAsyncCollector használatávalQueue trigger, write docs using IAsyncCollector

Hagyja ki a kimeneti példaSkip output examples

Üzenetsor eseményindító írási egy dokumentumot (C#-szkript)Queue trigger, write one doc (C# script)

Az alábbi példa bemutatja egy Azure Cosmos DB kimeneti kötésének az egy function.json fájl és a egy C#-szkriptfüggvény , amely a kötés használja.The following example shows an Azure Cosmos DB output binding in a function.json file and a C# script function that uses the binding. A függvény egy bemeneti várólista-kötést használja egy üzenetsor, amely megkapja a JSON a következő formátumban:The function uses a queue input binding for a queue that receives JSON in the following format:

{
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

A függvény minden egyes rekord a következő formátumban hozza létre az Azure Cosmos DB-dokumentumot:The function creates Azure Cosmos DB documents in the following format for each record:

{
    "id": "John Henry-123456",
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

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

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

Íme a C#-szkriptkódot:Here's the C# script code:

    #r "Newtonsoft.Json"

    using Microsoft.Azure.WebJobs.Host;
    using Newtonsoft.Json.Linq;
    using Microsoft.Extensions.Logging;

    public static void Run(string myQueueItem, out object employeeDocument, ILogger log)
    {
      log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");

      dynamic employee = JObject.Parse(myQueueItem);

      employeeDocument = new {
        id = employee.name + "-" + employee.employeeId,
        name = employee.name,
        employeeId = employee.employeeId,
        address = employee.address
      };
    }

Üzenetsor eseményindító írási docs IAsyncCollector használatávalQueue trigger, write docs using IAsyncCollector

Több dokumentumot létrehozni, hogy hozhasson létre ICollector<T> vagy IAsyncCollector<T> ahol T a támogatott típusok egyike.To create multiple documents, you can bind to ICollector<T> or IAsyncCollector<T> where T is one of the supported types.

Ebben a példában egy egyszerű hivatkozik ToDoItem típusa:This example refers to a simple ToDoItem type:

namespace CosmosDBSamplesV2
{
    public class ToDoItem
    {
        public string Id { get; set; }
        public string Description { get; set; }
    }
}

Íme a function.json fájlban:Here's the function.json file:

{
  "bindings": [
    {
      "name": "toDoItemsIn",
      "type": "queueTrigger",
      "direction": "in",
      "queueName": "todoqueueforwritemulti",
      "connectionStringSetting": "AzureWebJobsStorage"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItemsOut",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "out"
    }
  ],
  "disabled": false
}

Íme a C#-szkriptkódot:Here's the C# script code:

using System;
using Microsoft.Extensions.Logging;

public static async Task Run(ToDoItem[] toDoItemsIn, IAsyncCollector<ToDoItem> toDoItemsOut, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

    foreach (ToDoItem toDoItem in toDoItemsIn)
    {
        log.LogInformation($"Description={toDoItem.Description}");
        await toDoItemsOut.AddAsync(toDoItem);
    }
}

Hagyja ki a kimeneti példaSkip output examples

Kimenet – JavaScript-példákOutput - JavaScript examples

Az alábbi példa bemutatja egy Azure Cosmos DB kimeneti kötésének az egy function.json fájl és a egy JavaScript-függvény , amely a kötés használja.The following example shows an Azure Cosmos DB output binding in a function.json file and a JavaScript function that uses the binding. A függvény egy bemeneti várólista-kötést használja egy üzenetsor, amely megkapja a JSON a következő formátumban:The function uses a queue input binding for a queue that receives JSON in the following format:

{
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

A függvény minden egyes rekord a következő formátumban hozza létre az Azure Cosmos DB-dokumentumot:The function creates Azure Cosmos DB documents in the following format for each record:

{
    "id": "John Henry-123456",
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

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

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

A következő JavaScript-kódot:Here's the JavaScript code:

    module.exports = function (context) {

      context.bindings.employeeDocument = JSON.stringify({
        id: context.bindings.myQueueItem.name + "-" + context.bindings.myQueueItem.employeeId,
        name: context.bindings.myQueueItem.name,
        employeeId: context.bindings.myQueueItem.employeeId,
        address: context.bindings.myQueueItem.address
      });

      context.done();
    };

Hagyja ki a kimeneti példaSkip output examples

Kimenete – F# példákOutput - F# examples

Az alábbi példa bemutatja egy Azure Cosmos DB kimeneti kötésének az egy function.json fájl és a egy F# függvény , amely a kötés használja.The following example shows an Azure Cosmos DB output binding in a function.json file and an F# function that uses the binding. A függvény egy bemeneti várólista-kötést használja egy üzenetsor, amely megkapja a JSON a következő formátumban:The function uses a queue input binding for a queue that receives JSON in the following format:

{
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

A függvény minden egyes rekord a következő formátumban hozza létre az Azure Cosmos DB-dokumentumot:The function creates Azure Cosmos DB documents in the following format for each record:

{
    "id": "John Henry-123456",
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

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

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

Íme a F# kódot:Here's the F# code:

    open FSharp.Interop.Dynamic
    open Newtonsoft.Json
    open Microsoft.Extensions.Logging

    type Employee = {
      id: string
      name: string
      employeeId: string
      address: string
    }

    let Run(myQueueItem: string, employeeDocument: byref<obj>, log: ILogger) =
      log.LogInformation(sprintf "F# Queue trigger function processed: %s" myQueueItem)
      let employee = JObject.Parse(myQueueItem)
      employeeDocument <-
        { id = sprintf "%s-%s" employee?name employee?employeeId
          name = employee?name
          employeeId = employee?employeeId
          address = employee?address }

Ebben a példában van szükség egy project.json fájlt, amely meghatározza a FSharp.Interop.Dynamic és Dynamitey NuGet-függőségek:This example requires a project.json file that specifies the FSharp.Interop.Dynamic and Dynamitey NuGet dependencies:

{
    "frameworks": {
        "net46": {
          "dependencies": {
            "Dynamitey": "1.0.2",
            "FSharp.Interop.Dynamic": "3.0.0"
           }
        }
    }
}

Hozzáadása egy project.json fájlt F# felügyeleti csomag.To add a project.json file, see F# package management.

Kimenet – Java-példákOutput - Java examples

Üzenetsor-trigger, üzenet mentése az adatbázisba visszatérési érték (Java) használatávalQueue trigger, save message to database via return value (Java)

Az alábbi példa egy Java-függvényt mutat be, amely egy dokumentumot hoz létre egy, a várólista-tárolóban lévő üzenetből származó adatokkal rendelkező adatbázishoz.The following example shows a Java function that adds a document to a database with data from a message in 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-trigger, egy dokumentum mentése az adatbázisba visszatérési értékkel (Java)HTTP trigger, save one document to database via return value (Java)

Az alábbi példa egy olyan Java-függvényt mutat be, amelynek @CosmosDBOutput aláírását a és a érték Stringtípusa adja vissza.The following example shows a Java function whose signature is annotated with @CosmosDBOutput and has return value of type String. A függvény által visszaadott JSON-dokumentum automatikusan a megfelelő CosmosDB-gyűjteménybe lesz írva.The JSON document returned by the function will be automatically written to the corresponding CosmosDB collection.

    @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-trigger, egy dokumentum mentése az adatbázisba a OutputBinding (Java) használatávalHTTP trigger, save one document to database via OutputBinding (Java)

Az alábbi példa egy Java-függvényt mutat be, amely egy CosmosDB egy OutputBinding<T> kimeneti paraméter használatával ír egy dokumentumot.The following example shows a Java function that writes a document to CosmosDB via an OutputBinding<T> output parameter. Vegye figyelembe, hogy ebben a beállításban ez az outputItem a paraméter, amelyet a függvény aláírásával @CosmosDBOutputkell kiegészíteni.Note that, in this setup, it is the outputItem parameter that needs to be annotated with @CosmosDBOutput, not the function signature. A OutputBinding<T> használata lehetővé teszi a függvény számára, hogy kihasználhassa a dokumentumot a CosmosDB, miközben lehetővé teszi, hogy más értéket adjanak vissza a függvény hívójának, például egy JSON-vagy XML-dokumentumnak.Using OutputBinding<T> lets your function take advantage of the binding to write the document to CosmosDB while also allowing returning a different value to the function caller, such as a JSON or XML document.

    @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-trigger, több dokumentum mentése az adatbázisba a OutputBinding (Java) használatávalHTTP trigger, save multiple documents to database via OutputBinding (Java)

Az alábbi példa egy Java-függvényt mutat be, amely egy OutputBinding<T> kimeneti paraméterrel több dokumentumot ír a CosmosDB.The following example shows a Java function that writes multiple documents to CosmosDB via an OutputBinding<T> output parameter. Vegye figyelembe, hogy ebben a beállításban ez az outputItem a paraméter, amelyet a függvény aláírásával @CosmosDBOutputkell kiegészíteni.Note that, in this setup, it is the outputItem parameter that needs to be annotated with @CosmosDBOutput, not the function signature. A kimeneti paraméter outputItem az ToDoItem objektumok listáját tartalmazza, mint a sablon paraméterének típusa.The output parameter, outputItem has a list of ToDoItem objects as its template parameter type. A OutputBinding<T> használata lehetővé teszi, hogy a függvény kihasználhassa a dokumentumokat a CosmosDB, miközben lehetővé teszi, hogy más értéket írjon vissza a függvény hívója számára, például egy JSON-vagy XML-dokumentumot.Using OutputBinding<T> lets your function take advantage of the binding to write the documents to CosmosDB while also allowing returning a different value to the function caller, such as a JSON or XML document.

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

A Java functions runtime library-ben használja @CosmosDBOutput az Cosmos DBba írandó paraméterek megjegyzéseit.In the Java functions runtime library, use the @CosmosDBOutput annotation on parameters that will be written to Cosmos DB. A Megjegyzés paraméterének a következőnek OutputBinding<T>kell lennie:, ahol a T egy natív Java-típus vagy egy POJO.The annotation parameter type should be OutputBinding<T>, where T is either a native Java type or a POJO.

Kimenet – Python-példákOutput - Python examples

Az alábbi példa azt mutatja be, hogyan írhat dokumentumokat egy Azure CosmosDB-adatbázisba egy függvény kimenete.The following example demonstrates how to write a document to an Azure CosmosDB database as the output of a function.

A kötés definíciója a function. JSON fájlban van megadva, ahol a cosmosDBType értéke a következő :.The binding definition is defined in function.json where type is set to cosmosDB.

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

Az adatbázisba való íráshoz adjon át egy dokumentum-objektumot set az adatbázis-paraméter metódusának.To write to the database, pass a document object to the set method of the database parameter.

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'

Kimenet – attribútumokOutput - attributes

Az C# osztályok könyvtáraibanhasználja a CosmosDB attribútumot.In C# class libraries, use the CosmosDB attribute.

Az attribútum konstruktorának paramétereként meg az adatbázis és gyűjtemény nevét.The attribute's constructor takes the database name and collection name. Ezek a beállítások és más tulajdonságokat is beállíthat kapcsolatos információkért lásd: kimenete – konfigurációs.For information about those settings and other properties that you can configure, see Output - configuration. Íme egy CosmosDB attribútum példa egy podpis metody:Here's a CosmosDB attribute example in a method signature:

    [FunctionName("QueueToDocDB")]
    public static void Run(
        [QueueTrigger("myqueue-items", Connection = "AzureWebJobsStorage")] string myQueueItem,
        [CosmosDB("ToDoList", "Items", Id = "id", ConnectionStringSetting = "myCosmosDB")] out dynamic document)
    {
        ...
    }

Teljes példa: kimenet – C# példa.For a complete example, see Output - C# example.

Kimenete – konfigurációOutput - configuration

A következő táblázat ismerteti a megadott kötés konfigurációs tulajdonságaiban a function.json fájlt, és a CosmosDB attribútum.The following table explains the binding configuration properties that you set in the function.json file and the CosmosDB attribute.

Function.JSON tulajdonságfunction.json property Attribútum tulajdonságaAttribute property LeírásDescription
typetype Meg kell cosmosDB.Must be set to cosmosDB.
directiondirection Meg kell out.Must be set to out.
namename A kötési paraméter, amely a dokumentumot, a függvény neve.Name of the binding parameter that represents the document in the function.
databaseNamedatabaseName databaseNameDatabaseName Az a gyűjtemény, amelyben létrehozza a dokumentumban tartalmazó adatbázis.The database containing the collection where the document is created.
collectionNamecollectionName collectionNameCollectionName A gyűjtemény, amelyben létrehozza a dokumentumban neve.The name of the collection where the document is created.
createIfNotExistscreateIfNotExists CreateIfNotExistsCreateIfNotExists Logikai érték jelzi, hogy a gyűjtemény létrehozásakor a rendszer még nem létezik.A boolean value to indicate whether the collection is created when it doesn't exist. Az alapértelmezett érték hamis , mert az új gyűjtemény hozható létre fenntartott átviteli sebesség, amelynek költsége van hatással.The default is false because new collections are created with reserved throughput, which has cost implications. További tájékoztatás a díjszabási lapon olvasható.For more information, see the pricing page.
partitionKeypartitionKey PartitionKeyPartitionKey Amikor CreateIfNotExists értéke true, határozza meg a partíciós kulcs elérési útja a létrehozott gyűjteményre.When CreateIfNotExists is true, defines the partition key path for the created collection.
collectionThroughputcollectionThroughput collectionThroughputCollectionThroughput Amikor CreateIfNotExists értéke true, határozza meg a átviteli a létrehozott gyűjtemény.When CreateIfNotExists is true, defines the throughput of the created collection.
connectionStringSettingconnectionStringSetting ConnectionStringSettingConnectionStringSetting Az Azure Cosmos DB kapcsolati sztringjét tartalmazó alkalmazásbeállítás neve.The name of the app setting containing your Azure Cosmos DB connection string.

Ha helyileg fejleszt, Alkalmazásbeállítások lépnek a local.settings.json fájljában.When you're developing locally, app settings go into the local.settings.json file.

Kimenet – használatOutput - usage

Alapértelmezés szerint ha a függvényben a kimeneti paraméter írni egy dokumentum létrehozása az adatbázisban.By default, when you write to the output parameter in your function, a document is created in your database. Ebben a dokumentumban az automatikusan előállított GUID Azonosítóhoz megegyezik a dokumentum azonosítója.This document has an automatically generated GUID as the document ID. Megadhatja a kimeneti dokumentum a dokumentumazonosító megadásával a id a kimeneti paraméter átadott tulajdonság a JSON-objektumban.You can specify the document ID of the output document by specifying the id property in the JSON object passed to the output parameter.

Megjegyzés

Létező dokumentum Azonosítóját adja meg, ha azt az új kimeneti dokumentum szerint felülíródik.When you specify the ID of an existing document, it gets overwritten by the new output document.

Kivételek és a visszatérési kódokExceptions and return codes

KötésBinding LeírásokReference
CosmosDBCosmosDB CosmosDB-hibakódokCosmosDB Error Codes

Host.JSON-beállításokhost.json settings

Ez a szakasz ismerteti a globális konfigurációs beállításoknak a kötéshez verziójában elérhető 2.x.This section describes the global configuration settings available for this binding in version 2.x. További információ a globális konfigurációs beállításoknak verzióban 2.x verzióját, lásd: verzióját az Azure Functions – host.json referencia 2.x.For more information about global configuration settings in version 2.x, see host.json reference for Azure Functions version 2.x.

{
    "version": "2.0",
    "extensions": {
        "cosmosDB": {
            "connectionMode": "Gateway",
            "protocol": "Https",
            "leaseOptions": {
                "leasePrefix": "prefix1"
            }
        }
    }
}
TulajdonságProperty AlapértelmezettDefault LeírásDescription
GatewayModeGatewayMode ÁtjáróGateway A függvény által a Azure Cosmos DB szolgáltatáshoz való csatlakozáskor használt kapcsolati mód.The connection mode used by the function when connecting to the Azure Cosmos DB service. A lehetőségek Direct a következők,GatewayOptions are Direct and Gateway
ProtocolProtocol HttpsHttps A függvény által a Azure Cosmos DB szolgáltatáshoz való kapcsolódáskor használt kapcsolati protokoll.The connection protocol used by the function when connection to the Azure Cosmos DB service. A két mód magyarázata itt olvashatóRead here for an explanation of both modes
leasePrefixleasePrefix n/an/a Az alkalmazás összes függvényében használandó bérlet-előtag.Lease prefix to use across all functions in an app.

További lépésekNext steps