Azure Cosmos DB kimeneti kötés az Azure Functions 2.x és újabb verzióihoz

Az Azure Cosmos DB kimeneti kötésével új dokumentumot írhat egy Azure Cosmos DB-adatbázisba az SQL API használatával.

A beállítással és a konfigurációval kapcsolatos információkért tekintse meg az áttekintést.

Fontos

Ez a cikk lapokat használ a Node.js programozási modell több verziójának támogatásához. A v4-modell általánosan elérhető, és úgy lett kialakítva, hogy rugalmasabb és intuitívabb felhasználói élményt nyújtson JavaScript- és TypeScript-fejlesztők számára. A v4-modell működésével kapcsolatos további információkért tekintse meg az Azure Functions Node.js fejlesztői útmutatóját. A v3 és a v4 közötti különbségekről a migrálási útmutatóban olvashat bővebben.

Az Azure Functions két Python-programozási modellt támogat. A kötések definiálásának módja a választott programozási modelltől függ.

v2

A Python v2 programozási modell lehetővé teszi, hogy a kötéseket dekorátorokkal definiálja közvetlenül a Python-függvénykódban. További információt a Python fejlesztői útmutatójában talál.

v1

A Python v1 programozási modell megköveteli, hogy a függvénymappában egy külön function.json fájlban definiáljon kötéseket. További információt a Python fejlesztői útmutatójában talál.

Ez a cikk mindkét programozási modellt támogatja.

A C#-függvények a következő C#-módok egyikével hozhatók létre:

• Izolált feldolgozómodell: Lefordított C# függvény, amely a futtatókörnyezettől elkülönített feldolgozói folyamatban fut. Izolált feldolgozói folyamat szükséges az LTS- és nem LTS-verziókon futó C#-függvények támogatásához .NET és .NET-keretrendszer. Az izolált feldolgozói folyamatfüggvények bővítményei névtereket használnak Microsoft.Azure.Functions.Worker.Extensions.* .
• Folyamaton belüli modell: Lefordított C# függvény, amely ugyanabban a folyamatban fut, mint a Functions-futtatókörnyezet. A modell egy változatában a Functions C#-szkriptekkel futtatható, amely elsősorban a C#-portál szerkesztéséhez támogatott. A folyamaton belüli függvények bővítményei névtereket használnak Microsoft.Azure.WebJobs.Extensions.* .

Fontos

A folyamaton belüli modell támogatása 2026. november 10-én megszűnik. Erősen javasoljuk, hogy az alkalmazásokat az elkülönített feldolgozói modellbe migrálja a teljes támogatás érdekében.

Példa

Ha másként nem jelezzük, a cikkben szereplő példák az Azure Cosmos DB-bővítmény 3.x-es verzióját célják. A 4.x-es verziójú bővítményhez a tulajdonság- és attribútumnevek sztringjének collection lecserélése a következőre és connection_string_setting a következőreconnection: .container

Izolált feldolgozói modell

A következő kód egy típust MyDocument határoz meg:

public class MyDocument
{
    public string Id { get; set; }

    public string Text { get; set; }

    public int Number { get; set; }

    public bool Boolean { get; set; }
}

A következő példában a visszatérési típus egy IReadOnlyList<T>, amely az eseményindító kötési paraméteréből származó dokumentumok módosított listája:

using System.Collections.Generic;
using System.Linq;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace SampleApp
{
    public class CosmosDBFunction
    {
        private readonly ILogger<CosmosDBFunction> _logger;

        public CosmosDBFunction(ILogger<CosmosDBFunction> logger)
        {
            _logger = logger;
        }

        //<docsnippet_exponential_backoff_retry_example>
        [Function(nameof(CosmosDBFunction))]
        [ExponentialBackoffRetry(5, "00:00:04", "00:15:00")]
        [CosmosDBOutput("%CosmosDb%", "%CosmosContainerOut%", Connection = "CosmosDBConnection", CreateIfNotExists = true)]
        public object Run(
            [CosmosDBTrigger(
                "%CosmosDb%",
                "%CosmosContainerIn%",
                Connection = "CosmosDBConnection",
                LeaseContainerName = "leases",
                CreateLeaseContainerIfNotExists = true)] IReadOnlyList<MyDocument> input,
            FunctionContext context)
        {
            if (input != null && input.Any())
            {
                foreach (var doc in input)
                {
                    _logger.LogInformation("Doc Id: {id}", doc.Id);
                }

                // Cosmos Output
                return input.Select(p => new { id = p.Id });
            }

            return null;
        }
        //</docsnippet_exponential_backoff_retry_example>
    }

Folyamaton belüli modell

Ez a szakasz a következő példákat tartalmazza:

• Üzenetsor-eseményindító, egy dokumentum írása
• Üzenetsor-eseményindító, egy dokumentum írása (v4-bővítmény)
• Üzenetsor-eseményindító, dokumentumok írása az IAsyncCollector használatával

A példák egy egyszerű ToDoItem típusra vonatkoznak:

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

Üzenetsor-eseményindító, egy dokumentum írása

Az alábbi példa egy C# függvényt mutat be, amely egy dokumentumot ad hozzá egy adatbázishoz a Queue Storage üzenetében megadott adatok használatával.

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

Üzenetsor-eseményindító, egy dokumentum írása (v4-bővítmény)

Az Azure Cosmos DB-bővítmény 4.x vagy újabb verzióját használó alkalmazások különböző attribútumtulajdonságokkal rendelkeznek, amelyek az alábbiakban láthatók. Az alábbi példa egy C# függvényt mutat be, amely egy dokumentumot ad hozzá egy adatbázishoz a Queue Storage üzenetében megadott adatok használatával.

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",
                containerName: "Items",
                Connection = "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}");
        }
    }
}

Üzenetsor-eseményindító, dokumentumok írása az IAsyncCollector használatával

Az alábbi példa egy C# függvényt mutat be, amely dokumentumgyűjteményt ad hozzá egy adatbázishoz egy JSON üzenetben megadott adatok használatával.

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

• Üzenetsor-eseményindító, üzenet mentése az adatbázisba visszatérési értéken keresztül
• HTTP-eseményindító, egy dokumentum mentése az adatbázisba visszatérési értéken keresztül
• HTTP-eseményindító, mentsen egy dokumentumot az adatbázisba az OutputBinding használatával
• HTTP-eseményindító, több dokumentum mentése adatbázisba OutputBinding használatával

Üzenetsor-eseményindító, üzenet mentése az adatbázisba visszatérési értéken keresztül

Az alábbi példa egy Java-függvényt mutat be, amely egy dokumentumot ad hozzá egy adatbázishoz egy üzenetből származó adatokkal a Queue Storage-ban.

@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-eseményindító, egy dokumentum mentése az adatbázisba visszatérési értéken keresztül

Az alábbi példa egy Java-függvényt mutat be, amelynek az aláírása megjegyzéssel @CosmosDBOutput van elfűzve, és típusértékkel Stringrendelkezik. A függvény által visszaadott JSON-dokumentum automatikusan meg lesz írva a megfelelő Azure Cosmos DB-gyűjteménybe.

    @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-eseményindító, mentsen egy dokumentumot az adatbázisba az OutputBinding használatával

Az alábbi példa egy Java-függvényt mutat be, amely egy kimeneti paraméteren keresztül ír egy dokumentumot az OutputBinding<T> Azure Cosmos DB-be. Ebben a példában a outputItem paramétert nem a függvény-aláírással, hanem jegyzetekkel @CosmosDBOutputkell írni. A OutputBinding<T> használatával a függvény kihasználhatja a kötés előnyeit a dokumentum Azure Cosmos DB-be való írásához, ugyanakkor lehetővé teszi egy másik érték visszaadását a függvényhívónak, például egy JSON- vagy XML-dokumentumot.

    @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-eseményindító, több dokumentum mentése adatbázisba OutputBinding használatával

Az alábbi példa egy Java-függvényt mutat be, amely több dokumentumot ír az Azure Cosmos DB-be egy OutputBinding<T> kimeneti paraméteren keresztül. Ebben a példában a outputItem paraméter nem a függvény-aláírással, hanem a jegyzetekkel @CosmosDBOutputvan elfűzve. A kimeneti paraméter outputItem sablonparaméter-típusként az objektumok listáját ToDoItem tartalmazza. A OutputBinding<T> használatával a függvény kihasználhatja a kötés előnyeit a dokumentumok Azure Cosmos DB-be való írásához, ugyanakkor lehetővé teszi egy másik érték visszaadását a függvényhívónak, például egy JSON- vagy XML-dokumentumot.

    @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-függvények futtatókörnyezeti kódtárában használja a jegyzetet az @CosmosDBOutput Azure Cosmos DB-be írandó paramétereken. A széljegyzetparaméter típusának olyannak kell lennie, ahol T natív Java- vagy POJO-típust kell megadniOutputBinding<T>.

Modell v4

Az alábbi példa egy, a JSON-t fogadó üzenetsorhoz aktivált TypeScript-függvényt mutat be egy olyan üzenetsorhoz, amely a következő formátumban fogadja a JSON-t:

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

A függvény minden rekordhoz az alábbi formátumban hozza létre az Azure Cosmos DB-dokumentumokat:

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

A TypeScript-kód a következő:

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

interface MyQueueItem {
    name: string;
    employeeId: string;
    address: string;
}

interface MyCosmosItem {
    id: string;
    name: string;
    employeeId: string;
    address: string;
}

export async function storageQueueTrigger1(queueItem: MyQueueItem, context: InvocationContext): Promise<MyCosmosItem> {
    return {
        id: `${queueItem.name}-${queueItem.employeeId}`,
        name: queueItem.name,
        employeeId: queueItem.employeeId,
        address: queueItem.address,
    };
}

app.storageQueue('storageQueueTrigger1', {
    queueName: 'inputqueue',
    connection: 'MyStorageConnectionAppSetting',
    return: output.cosmosDB({
        databaseName: 'MyDatabase',
        collectionName: 'MyCollection',
        createIfNotExists: true,
        connectionStringSetting: 'MyAccount_COSMOSDB',
    }),
    handler: storageQueueTrigger1,
});

Több dokumentum kimenetéhez egyetlen objektum helyett egy tömböt kell visszaadnia. Példa:

return [
    {
        id: 'John Henry-123456',
        name: 'John Henry',
        employeeId: '123456',
        address: 'A town nearby',
    },
    {
        id: 'John Doe-123457',
        name: 'John Doe',
        employeeId: '123457',
        address: 'A town far away',
    },
];

Modell v3

A TypeScript-minták nincsenek dokumentálva a v3-as modellhez.

Modell v4

Az alábbi példa egy tárolósor által aktivált JavaScript-függvényt mutat be egy üzenetsorhoz, amely a következő formátumban fogadja a JSON-t:

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

A függvény minden rekordhoz az alábbi formátumban hozza létre az Azure Cosmos DB-dokumentumokat:

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

A JavaScript-kód a következő:

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

const cosmosOutput = output.cosmosDB({
    databaseName: 'MyDatabase',
    collectionName: 'MyCollection',
    createIfNotExists: true,
    connectionStringSetting: 'MyAccount_COSMOSDB',
});

app.storageQueue('storageQueueTrigger1', {
    queueName: 'inputqueue',
    connection: 'MyStorageConnectionAppSetting',
    return: cosmosOutput,
    handler: (queueItem, context) => {
        return {
            id: `${queueItem.name}-${queueItem.employeeId}`,
            name: queueItem.name,
            employeeId: queueItem.employeeId,
            address: queueItem.address,
        };
    },
});

Több dokumentum kimenetéhez egyetlen objektum helyett egy tömböt kell visszaadnia. Példa:

return [
    {
        id: 'John Henry-123456',
        name: 'John Henry',
        employeeId: '123456',
        address: 'A town nearby',
    },
    {
        id: 'John Doe-123457',
        name: 'John Doe',
        employeeId: '123457',
        address: 'A town far away',
    },
];

Modell v3

Az alábbi példa egy Azure Cosmos DB kimeneti kötést mutat be egy function.json fájlban, és egy JavaScript-függvényt , amely a kötést használja. A függvény egy üzenetsor bemeneti kötését használja egy üzenetsorhoz, amely a következő formátumban fogadja a JSON-t:

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

A függvény minden rekordhoz az alábbi formátumban hozza létre az Azure Cosmos DB-dokumentumokat:

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

A kötési adatok a function.json fájlban:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A JavaScript-kód a következő:

    module.exports = async 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
      });
    };

Tömeges beszúrás esetén először az objektumokat formázza, majd futtassa a sztringify függvényt. A JavaScript-kód a következő:

    module.exports = async function (context) {

        context.bindings.employeeDocument = JSON.stringify([
        {
            "id": "John Henry-123456",
            "name": "John Henry",
            "employeeId": "123456",
            "address": "A town nearby"
        },
        {
            "id": "John Doe-123457",
            "name": "John Doe",
            "employeeId": "123457",
            "address": "A town far away"
        }]);
    };

Az alábbi példa bemutatja, hogyan írhat adatokat az Azure Cosmos DB-be kimeneti kötés használatával. A kötés deklarálva van a függvény konfigurációs fájljában (functions.json), és adatokat vesz fel egy üzenetsorból, és egy Azure Cosmos DB-dokumentumba ír.

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

A run.ps1 fájlban a függvényből visszaadott objektum egy EmployeeDocument objektumhoz van megfeleltetve, amely megmarad az adatbázisban.

param($QueueItem, $TriggerMetadata) 

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

Az alábbi példa bemutatja, hogyan írhat dokumentumot egy Azure Cosmos DB-adatbázisba egy függvény kimeneteként. A példa attól függ, hogy a v1 vagy v2 Python programozási modellt használja-e.

v2

import logging
import azure.functions as func

app = func.FunctionApp()

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

v1

A kötésdefiníció function.json van definiálva cosmosDB, ahol a típus értéke .

{
  "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 dokumentumobjektumot az set adatbázisparaméter metódusának.

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'

Attribútumok

A folyamaton belüli és az izolált feldolgozói folyamat C# kódtárai attribútumokkal határozzák meg a függvényt. A C#-szkript ehelyett egy function.json konfigurációs fájlt használ a C#-szkriptelési útmutatóban leírtak szerint.

4.x+ bővítmény

Attribútumtulajdonság	Leírás
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a figyelt Azure Cosmos DB-fiókhoz. További információ: Csatlakozás.
DatabaseName	Az Azure Cosmos DB-adatbázis neve a figyelt tárolóval.
ContainerName	A figyelt tároló neve.
CreateIfNotExists	Logikai érték, amely jelzi, hogy a tároló akkor jön-e létre, ha nem létezik. Az alapértelmezett érték hamis, mert az új tárolók fenntartott átviteli sebességgel jönnek létre, ami költséghatással jár. További tájékoztatás a díjszabási oldalon olvasható.
PartitionKey	Ha CreateIfNotExists igaz, meghatározza a létrehozott tároló partíciókulcs-elérési útját. Tartalmazhat kötési paramétereket.
ContainerThroughput	Ha CreateIfNotExists igaz, meghatározza a létrehozott tároló átviteli sebességét .
PreferredLocations	(Nem kötelező) Meghatározza a földrajzilag replikált adatbázisfiókok előnyben részesített helyét (régióit) az Azure Cosmos DB szolgáltatásban. Az értékeket vesszővel kell elválasztani. Például: East US,South Central US,North Europe.

Functions 2.x+

Attribútumtulajdonság	Leírás
Csatlakozás ionStringSetting	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a figyelt Azure Cosmos DB-fiókhoz. További információ: Csatlakozás.
DatabaseName	Az Azure Cosmos DB-adatbázis neve a figyelt gyűjteménysel.
Lekérdezés_neve	A figyelt gyűjtemény neve.
CreateIfNotExists	Logikai érték, amely jelzi, hogy a gyűjtemény akkor jön-e létre, ha nem létezik. Az alapértelmezett érték hamis, mert az új gyűjtemények fenntartott átviteli sebességgel jönnek létre, ami költségekkel jár. További tájékoztatás a díjszabási oldalon olvasható.
PartitionKey	Ha CreateIfNotExists igaz, meghatározza a létrehozott gyűjtemény partíciókulcs-elérési útját. Tartalmazhat kötési paramétereket.
CollectionThroughput	Ha CreateIfNotExists igaz, meghatározza a létrehozott gyűjtemény átviteli sebességét .
PreferredLocations	(Nem kötelező) Meghatározza a földrajzilag replikált adatbázisfiókok előnyben részesített helyét (régióit) az Azure Cosmos DB szolgáltatásban. Az értékeket vesszővel kell elválasztani. Például: East US,South Central US,North Europe.
UseMultipleWriteLocations	(Nem kötelező) Ha ezzel együtt van true beállítva, támogatja a többrégiós írásokat az Azure Cosmos DB szolgáltatásbanPreferredLocations.

4.x+ bővítmény

Attribútumtulajdonság	Leírás
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a figyelt Azure Cosmos DB-fiókhoz. További információ: Csatlakozás.
DatabaseName	Az Azure Cosmos DB-adatbázis neve a figyelt tárolóval.
ContainerName	A figyelt tároló neve.
CreateIfNotExists	Logikai érték, amely jelzi, hogy a tároló akkor jön-e létre, ha nem létezik. Az alapértelmezett érték hamis, mert az új tárolók fenntartott átviteli sebességgel jönnek létre, ami költséghatással jár. További tájékoztatás a díjszabási oldalon olvasható.
PartitionKey	Ha CreateIfNotExists igaz, meghatározza a létrehozott tároló partíciókulcs-elérési útját. Tartalmazhat kötési paramétereket.
ContainerThroughput	Ha CreateIfNotExists igaz, meghatározza a létrehozott tároló átviteli sebességét .
PreferredLocations	(Nem kötelező) Meghatározza a földrajzilag replikált adatbázisfiókok előnyben részesített helyét (régióit) az Azure Cosmos DB szolgáltatásban. Az értékeket vesszővel kell elválasztani. Például: East US,South Central US,North Europe.

Functions 2.x+

Attribútumtulajdonság	Leírás
Csatlakozás ionStringSetting	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a figyelt Azure Cosmos DB-fiókhoz. További információ: Csatlakozás.
DatabaseName	Az Azure Cosmos DB-adatbázis neve a figyelt gyűjteménysel.
Lekérdezés_neve	A figyelt gyűjtemény neve.
CreateIfNotExists	Logikai érték, amely jelzi, hogy a gyűjtemény akkor jön-e létre, ha nem létezik. Az alapértelmezett érték hamis, mert az új gyűjtemények fenntartott átviteli sebességgel jönnek létre, ami költségekkel jár. További tájékoztatás a díjszabási oldalon olvasható.
PartitionKey	Ha CreateIfNotExists igaz, meghatározza a létrehozott gyűjtemény partíciókulcs-elérési útját. Tartalmazhat kötési paramétereket.
CollectionThroughput	Ha CreateIfNotExists igaz, meghatározza a létrehozott gyűjtemény átviteli sebességét .
PreferredLocations	(Nem kötelező) Meghatározza a földrajzilag replikált adatbázisfiókok előnyben részesített helyét (régióit) az Azure Cosmos DB szolgáltatásban. Az értékeket vesszővel kell elválasztani. Például: East US,South Central US,North Europe.
UseMultipleWriteLocations	(Nem kötelező) Ha ezzel együtt van true beállítva, támogatja a többrégiós írásokat az Azure Cosmos DB szolgáltatásbanPreferredLocations.

Dekorátorok

Csak a Python v2 programozási modellre vonatkozik.

A dekoratőrrel definiált Python v2-függvények esetében a következő tulajdonságok a cosmos_db_outputkövetkezők:

Tulajdonság	Leírás
arg_name	A függvénykódban használt változónév, amely a módosításokat tartalmazó dokumentumok listáját jelöli.
database_name	Az Azure Cosmos DB-adatbázis neve a figyelt gyűjteménysel.
collection_name	A figyelt Azure Cosmos DB-gyűjtemény neve.
create_if_not_exists	Logikai érték, amely azt jelzi, hogy létre kell-e hozni az adatbázist és a gyűjteményt, ha nem léteznek.
connection_string_setting	A figyelt Azure Cosmos DB kapcsolati sztring.

A function.json használatával definiált Python-függvények esetében lásd a Konfiguráció szakaszt.

Jegyzetek

A Java-függvények futtatókörnyezeti kódtárában használja a jegyzetet az @CosmosDBOutput Azure Cosmos DB-be író paramétereken. A széljegyzet a következő tulajdonságokat támogatja:

• név
• connectionStringSetting
• databaseName
• Lekérdezés_neve
• createIfNotExists
• Adattípus
• partitionKey
• preferredLocations
• useMultipleWriteLocations

Konfiguráció

Csak a Python v1 programozási modellre vonatkozik.

Modell v4

Az alábbi táblázat a metódusnak output.cosmosDB() átadott objektumon options beállítható tulajdonságokat ismerteti. A type, directionés name a tulajdonságok nem vonatkoznak a v4-modellre.

Modell v3

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti, ahol a tulajdonságok bővítményverziónként eltérnek:

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti, ahol a tulajdonságok bővítményverziónként eltérnek:

4.x+ bővítmény

function.json tulajdonság	Leírás
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a figyelt Azure Cosmos DB-fiókhoz. További információ: Csatlakozás.
databaseName	Az Azure Cosmos DB-adatbázis neve a figyelt tárolóval.
containerName	A figyelt tároló neve.
createIfNotExists	Logikai érték, amely jelzi, hogy a tároló akkor jön-e létre, ha nem létezik. Az alapértelmezett érték hamis, mert az új tárolók fenntartott átviteli sebességgel jönnek létre, ami költséghatással jár. További tájékoztatás a díjszabási oldalon olvasható.
partitionKey	Ha createIfNotExists igaz, meghatározza a létrehozott tároló partíciókulcs-elérési útját. Tartalmazhat kötési paramétereket.
containerThroughput	Ha createIfNotExists igaz, meghatározza a létrehozott tároló átviteli sebességét .
preferredLocations	(Nem kötelező) Meghatározza a földrajzilag replikált adatbázisfiókok előnyben részesített helyét (régióit) az Azure Cosmos DB szolgáltatásban. Az értékeket vesszővel kell elválasztani. Például: East US,South Central US,North Europe.

Functions 2.x+

function.json tulajdonság	Leírás
connectionStringSetting	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a figyelt Azure Cosmos DB-fiókhoz. További információ: Csatlakozás.
databaseName	Az Azure Cosmos DB-adatbázis neve a figyelt gyűjteménysel.
Lekérdezés_neve	A figyelt gyűjtemény neve.
createIfNotExists	Logikai érték, amely jelzi, hogy a gyűjtemény akkor jön-e létre, ha nem létezik. Az alapértelmezett érték hamis, mert az új gyűjtemények fenntartott átviteli sebességgel jönnek létre, ami költségekkel jár. További tájékoztatás a díjszabási oldalon olvasható.
partitionKey	Ha createIfNotExists igaz, meghatározza a létrehozott gyűjtemény partíciókulcs-elérési útját. Tartalmazhat kötési paramétereket.
collectionThroughput	Ha createIfNotExists igaz, meghatározza a létrehozott gyűjtemény átviteli sebességét .
preferredLocations	(Nem kötelező) Meghatározza a földrajzilag replikált adatbázisfiókok előnyben részesített helyét (régióit) az Azure Cosmos DB szolgáltatásban. Az értékeket vesszővel kell elválasztani. Például: East US,South Central US,North Europe.
useMultipleWriteLocations	(Nem kötelező) Ha ezzel együtt van true beállítva, támogatja a többrégiós írásokat az Azure Cosmos DB szolgáltatásbanpreferredLocations.

A teljes példákért tekintse meg a Példa szakaszt .

Használat

Alapértelmezés szerint, amikor a függvény kimeneti paraméterére ír, a rendszer létrehoz egy dokumentumot az adatbázisban. A kimeneti dokumentum dokumentumazonosítóját úgy kell megadnia, hogy megadja a id kimeneti paraméternek átadott JSON-objektum tulajdonságát.

Feljegyzés

Egy meglévő dokumentum azonosítójának megadásakor az új kimeneti dokumentum felülírja azt.

A Cosmos DB kimeneti kötés által támogatott paramétertípus a Functions futtatókörnyezet verziójától, a bővítménycsomag verziójától és a használt C# módtól függ.

4.x+ bővítmény

A támogatott típusok listáját a Kötéstípusok című témakörben találja.

Functions 2.x+

A támogatott típusok listáját a Kötéstípusok című témakörben találja.

4.x+ bővítmény

Ha azt szeretné, hogy a függvény egyetlen dokumentumba írjon, a Cosmos DB kimeneti kötése a következő típusokhoz köthet:

Típus	Leírás
JSON szerializálható típusok	Egy dokumentum JSON-tartalmát képviselő objektum. A Functions egy egyszerű régi CLR-objektum (POCO) típust próbál JSON-adatokká szerializálni.

Ha azt szeretné, hogy a függvény több dokumentumba írjon, a Cosmos DB kimeneti kötése a következő típusokhoz köthet:

Típus	Leírás
T[] hol T van JSON szerializálható típus	Több dokumentumot tartalmazó tömb. Minden bejegyzés egy dokumentumot jelöl.

Egyéb kimeneti forgatókönyvek esetén közvetlenül a Microsoft.Azure.Cosmosból hozhat létre és használhat típusokat .

Functions 2.x+

A támogatott típusok listáját a Kötéstípusok című témakörben találja.

Kapcsolatok

A connectionStringSetting/connection tulajdonságok a leaseConnectionStringSetting/leaseConnection környezetkonfigurációra mutató hivatkozások, amelyek meghatározzák, hogyan kell az alkalmazásnak csatlakoznia az Azure Cosmos DB-hez. A következőt határozhatják meg:

• Egy kapcsolati sztring tartalmazó alkalmazásbeállítás neve
• Egy megosztott előtag neve több alkalmazásbeállításhoz, valamint identitásalapú kapcsolat definiálása. Ez a beállítás csak a connectionleaseConnection bővítmény 4.x vagy újabb verziójához érhető el.

Ha a konfigurált érték egy adott beállítás pontos egyezése, a többi beállítás előtagja pedig egyezik, akkor a rendszer a pontos egyezést használja.

Kapcsolati sztring

Az adatbázisfiók kapcsolati sztring egy olyan alkalmazásbeállításban kell tárolni, amely a kötéskonfiguráció kapcsolattulajdonsága által megadott értéknek megfelelő névvel rendelkezik.

Identitásalapú kapcsolatok

Ha a bővítmény 4.x vagy újabb verzióját használja, ahelyett, hogy titkos kapcsolati sztring használ, az alkalmazás Microsoft Entra-identitást használhat. Ehhez egy közös előtagban definiálhat beállításokat, amelyek leképezik az eseményindító és a kötés konfigurációjának kapcsolat tulajdonságát.

Ebben a módban a bővítményhez a következő tulajdonságok szükségesek:

Tulajdonság	Környezeti változó sablonja	Leírás	Példaérték
Fiókvégpont	<CONNECTION_NAME_PREFIX>__accountEndpoint	Az Azure Cosmos DB-fiók végpontjának URI-ja.	<https:// database_account_name.documents.azure.com:443/>

További tulajdonságok is beállíthatók a kapcsolat testreszabásához. Tekintse meg az identitásalapú kapcsolatok gyakori tulajdonságait.

Az Azure Functions szolgáltatásban üzemeltetett identitásalapú kapcsolatok felügyelt identitást használnak. A rendszer alapértelmezés szerint a rendszer által hozzárendelt identitást használja, bár a felhasználó által hozzárendelt identitás megadható a credential tulajdonságokkal együtt clientID . Vegye figyelembe, hogy a felhasználó által hozzárendelt identitás erőforrás-azonosítóval való konfigurálása nem támogatott. Ha más környezetekben, például helyi fejlesztésben fut, a rendszer ehelyett a fejlesztői identitást használja, bár ez testre szabható. Lásd: Helyi fejlesztés identitásalapú kapcsolatokkal.

Engedély megadása az identitáshoz

Bármilyen identitást is használ, rendelkeznie kell a kívánt műveletek végrehajtásához szükséges engedélyekkel. A legtöbb Azure-szolgáltatás esetében ez azt jelenti, hogy egy szerepkört kell hozzárendelnie az Azure RBAC-ben beépített vagy egyéni szerepkörökkel, amelyek biztosítják ezeket az engedélyeket.

Fontos

A célszolgáltatás bizonyos engedélyeket közzétehet, amelyek nem minden környezethez szükségesek. Ahol lehetséges, tartsa be a minimális jogosultság elvét, és csak az identitáshoz szükséges jogosultságokat adja meg. Ha például az alkalmazásnak csak adatforrásból kell olvasnia, használjon olyan szerepkört, amely csak olvasási engedéllyel rendelkezik. Nem lenne helyénvaló olyan szerepkört hozzárendelni, amely lehetővé teszi az írást is a szolgáltatáshoz, mivel ez túlzott engedély lenne egy olvasási művelethez. Hasonlóképpen meg szeretné győződni arról, hogy a szerepkör-hozzárendelés csak az elolvasandó erőforrásokra terjed ki.

A Cosmos DB nem használja az Azure RBAC-t adatműveletekhez. Ehelyett egy Cosmos DB beépített RBAC-rendszert használ, amely hasonló fogalmakra épül. Létre kell hoznia egy szerepkör-hozzárendelést, amely futásidőben hozzáférést biztosít az adatbázisfiókhoz. Az Azure RBAC Management-szerepkörök, például a Tulajdonos nem elegendőek. Az alábbi táblázat azOkat a beépített szerepköröket mutatja be, amelyek az Azure Cosmos DB-bővítmény normál működésben való használatakor ajánlottak. Előfordulhat, hogy az alkalmazás további engedélyeket igényel az Ön által írt kód alapján.

Kötés típusa	Példa beépített szerepkörök1
Trigger2	A Cosmos DB beépített adatszolgáltatója
Bemeneti kötés	Cosmos DB beépített adatolvasó
Kimeneti kötés	A Cosmos DB beépített adatszolgáltatója

¹ Ezek a szerepkörök nem használhatók Azure RBAC-szerepkör-hozzárendelésben. A szerepkörök hozzárendelésével kapcsolatos részletekért tekintse meg a Cosmos DB beépített RBAC-rendszerdokumentációját .

² Identitás használatakor a Cosmos DB felügyeleti műveletként kezeli a tároló létrehozását. Nem érhető el adatsík-műveletként az eseményindítóhoz. A függvény beállítása előtt meg kell győződnie arról, hogy az eseményindítóhoz szükséges tárolókat hozza létre (beleértve a bérlettárolót is).

Kivételek és visszatérési kódok

Kötés	Referencia
Azure Cosmos DB	HTTP-állapotkódok az Azure Cosmos DB-hez

Következő lépések

• Függvény futtatása Azure Cosmos DB-dokumentum létrehozásakor vagy módosításakor (trigger)
• Azure Cosmos DB-dokumentum olvasása (bemeneti kötés)