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.
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.
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
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>
}
- Ü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 String
rendelkezik. 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 @CosmosDBOutput
kell í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 @CosmosDBOutput
van 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>
.
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',
},
];
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',
},
];
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.
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'
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.
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ó: Kapcsolatok. |
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 . |
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_output
kö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:
Konfiguráció
Csak a Python v1 programozási modellre vonatkozik.
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:
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ó: Kapcsolatok. |
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 . |
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.
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 .
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
connection
leaseConnection
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 |
1 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 .
2 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 |