Azure Functions Azure Blob storage eseményindítója

A Blob storage eseményindító új vagy frissített blob észlelésekor elindít egy függvényt. A blob tartalma a függvény inputjaként van megadva.

Tipp.

A függvénykódot többféleképpen is végrehajthatja egy storage tároló blobjainak módosítása alapján. Ha a Blob storage eseményindítót használja, két implementáció érhető el: egy lekérdezésalapú (ebben a cikkben hivatkozott) és egy eseményalapú. Javasoljuk, hogy az eseményalapú implementációt használja, mert kisebb a késése, mint a másiknak. Emellett a Flex Consumption csomag csak az eseményalapú Blob storage eseményindítót támogatja.

A Blob storage eseményindító két implementációja közötti különbségekről, valamint az egyéb aktiválási lehetőségekről a Blobok használata című témakörben olvashat.

A beállítási és konfigurációs részletekről a overview című témakörben olvashat.

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 a Azure Functions Node.js fejlesztői útmutatót. A v3 és a v4 közötti különbségekről a migrálási útmutatóban olvashat bővebben.

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.

Az Blob Storage eseményindító teljes körű használatára vonatkozó példa: Események blob storage Azure Functions használatával.

Példa

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 .NET és a .NET-keretrendszer támogatásához. Az izolált feldolgozói folyamatfüggvények bővítményei Microsoft.Azure.Functions.Worker.Extensions.* névtereket használnak.
  • 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 Microsoft.Azure.WebJobs.Extensions.* névtereket használnak.

Fontos

Támogatás 2026. november 10-én megszűnik a folyamatban lévő modell. Erősen javasoljuk, hogy az alkalmazásokat az izolált feldolgozói modellbe teljes körű támogatás érdekében.

Az alábbi példa egy C# függvény , amely egy izolált feldolgozófolyamatban fut, és blob-eseményindítót használ blobbemenettel és blobkimeneti blobkötésekkel. A függvényt egy blob létrehozása váltja ki a test-samples-trigger tárolóban. Beolvassa a szövegfájlt a test-samples-input tárolóból, és létrehoz egy új szövegfájlt egy kimeneti tárolóban az aktivált fájl neve alapján.

public static class BlobFunction
{
    [Function(nameof(BlobFunction))]
    [BlobOutput("test-samples-output/{name}-output.txt")]
    public static string Run(
        [BlobTrigger("test-samples-trigger/{name}")] string myTriggerItem,
        [BlobInput("test-samples-input/sample1.txt")] string myBlob,
        FunctionContext context)
    {
        var logger = context.GetLogger("BlobFunction");
        logger.LogInformation("Triggered Item = {myTriggerItem}", myTriggerItem);
        logger.LogInformation("Input Item = {myBlob}", myBlob);

        // Blob Output
        return "blob-output content";
    }
}

Ez a függvény egy bájttömb használatával naplót ír, amikor blobot adnak hozzá vagy frissítenek a myblob tárolóban.

Lekérdezésalapú:

Az alábbi példa az alapértelmezett lekérdezési eseményindítót használja:

@FunctionName("blobprocessor")
public void run(
  @BlobTrigger(name = "file",
               dataType = "binary",
               path = "myblob/{name}",
               connection = "MyStorageAccountAppSetting") byte[] content,
  @BindingName("name") String filename,
  final ExecutionContext context
) {
  context.getLogger().info("Name: " + filename + " Size: " + content.length + " bytes");
}

Az alábbi példa egy Event Grid-eseményindítót használ:

@FunctionName("blobprocessor")
public void run(
  @BlobTrigger(name = "file",
               dataType = "binary",
               path = "myblob/{name}",
               source = "EventGrid",
               connection = "MyStorageAccountAppSetting") byte[] content,
  @BindingName("name") String filename,
  final ExecutionContext context
) {
  context.getLogger().info("Name: " + filename + " Size: " + content.length + " bytes");
}

Ez a SDK típusú példa a blob tulajdonságainak access BlobClient használatával access.

@FunctionName("processBlob")
public void run(
        @BlobTrigger(
                name = "content",
                path = "images/{name}",
                connection = "AzureWebJobsStorage") BlobClient blob,
        @BindingName("name") String file,
        ExecutionContext ctx)
{
    ctx.getLogger().info("Size = " + blob.getProperties().getBlobSize());
}

Ez a SDK típusú példaBlobContainerClient használatával access információkat a függvényt aktiváló tárolóban lévő blobokról.

@FunctionName("containerOps")
public void run(
        @BlobTrigger(
                name = "content",
                path = "images/{name}",
                connection = "AzureWebJobsStorage") BlobContainerClient container,
        ExecutionContext ctx)
{
    container.listBlobs()
            .forEach(b -> ctx.getLogger().info(b.getName()));
}

Ez az SDK-típusok példa a végrehajtást kiváltó blob bemeneti kötéséből származó információk lekérésére szolgál BlobClient .

@FunctionName("checkAgainstInputBlob")
public void run(
        @BlobInput(
                name = "inputBlob",
                path = "inputContainer/input.txt") BlobClient inputBlob,
        @BlobTrigger(
                name = "content",
                path = "images/{name}",
                connection = "AzureWebJobsStorage",
                dataType = "string") String triggerBlob,
        ExecutionContext ctx)
{
    ctx.getLogger().info("Size = " + inputBlob.getProperties().getBlobSize());
}

Ez a példa bemutatja, hogyan szerezheti be a BlobClientet egy Storage Blob-eseményindítóból és egy HTTP-eseményindító bemeneti kötéséből:

import "@azure/functions-extensions-blob"; // This is the mandatory first import for SDK binding
import { StorageBlobClient } from "@azure/functions-extensions-blob";
import { app, InvocationContext } from "@azure/functions";

export async function storageBlobTrigger(
  blobStorageClient: StorageBlobClient, // SDK binding provides this client
  context: InvocationContext
): Promise<void> {
  context.log(`Blob trigger processing: ${context.triggerMetadata.name}`);

  // Access to full SDK capabilities
  const blobProperties = await blobStorageClient.blobClient.getProperties();
  context.log(`Blob size: ${blobProperties.contentLength}`);

  // Download blob content
  const downloadResponse = await blobStorageClient.blobClient.download();
  context.log(`Content: ${downloadResponse}`);
}

// Register the function
app.storageBlob("storageBlobTrigger", {
  path: "snippets/{name}",
  connection: "AzureWebJobsStorage",
  sdkBinding: true, // Enable SDK binding
  handler: storageBlobTrigger,
});

Ez a példa bemutatja, hogyan szerezheti be a ContainerClient egy Storage Blob bemeneti kötésből EGY HTTP-eseményindító használatával:

import "@azure/functions-extensions-blob"; // This is the mandatory first import for SDK binding
import { StorageBlobClient } from "@azure/functions-extensions-blob";
import {
  app,
  HttpRequest,
  HttpResponseInit,
  input,
  InvocationContext,
} from "@azure/functions";

const blobInput = input.storageBlob({
  path: "snippets",
  connection: "AzureWebJobsStorage",
  sdkBinding: true,
});

export async function listBlobs(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  // Get input binding for a specific container
  const storageBlobClient = context.extraInputs.get(
    blobInput
  ) as StorageBlobClient;

  // List all blobs in the container
  const blobs = [];
  for await (const blob of storageBlobClient.containerClient.listBlobsFlat()) {
    blobs.push(blob.name);
  }

  return { jsonBody: { blobs } };
}

app.http("listBlobs", {
  methods: ["GET"],
  authLevel: "function",
  extraInputs: [blobInput],
  handler: listBlobs,
});

Az alábbi példa egy TypeScript-kódot ábrázoló blob-eseményindítót mutat be. A függvény naplót ír, amikor blobot adnak hozzá vagy frissítenek a samples-workitems tárolóban.

A blob triggerútvonalában {name} sztring samples-workitems/{name} létrehoz egy binding kifejezést amelyet a függvénykódban használhat az eseményindító blob fájlnevének access. További információ: Blobnévminták a cikk későbbi részében.

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

export async function storageBlobTrigger1(blob: Buffer, context: InvocationContext): Promise<void> {
    context.log(
        `Storage blob function processed blob "${context.triggerMetadata.name}" with size ${blob.length} bytes`
    );
}

app.storageBlob('storageBlobTrigger1', {
    path: 'samples-workitems/{name}',
    connection: 'MyStorageAccountAppSetting',
    handler: storageBlobTrigger1,
});

Az alábbi példa egy Blob Trigger JavaScript-kódot mutat be. A függvény naplót ír, amikor blobot adnak hozzá vagy frissítenek a samples-workitems tárolóban.

A blob triggerútvonalában {name} sztring samples-workitems/{name} létrehoz egy binding kifejezést amelyet a függvénykódban használhat az eseményindító blob fájlnevének access. További információ: Blobnévminták a cikk későbbi részében.

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

app.storageBlob('storageBlobTrigger1', {
    path: 'samples-workitems/{name}',
    connection: 'MyStorageAccountAppSetting',
    handler: (blob, context) => {
        context.log(
            `Storage blob function processed blob "${context.triggerMetadata.name}" with size ${blob.length} bytes`
        );
    },
});

Az alábbi példa bemutatja, hogyan hozhat létre olyan függvényt, amely source blob storage tárolóhoz való fájl hozzáadásakor fut.

A függvénykonfigurációs fájl (function.json) tartalmaz egy kötést a typeblobTrigger következővel, és direction az értékre van inállítva.

{
  "bindings": [
    {
      "name": "InputBlob",
      "type": "blobTrigger",
      "direction": "in",
      "path": "source/{name}",
      "connection": "MyStorageAccountConnectionString"
    }
  ]
}

Itt találja a run.ps1 fájlhoz tartozó kódot.

param([byte[]] $InputBlob, $TriggerMetadata)

Write-Host "PowerShell Blob trigger: Name: $($TriggerMetadata.Name) Size: $($InputBlob.Length) bytes"

Ez a példa SDK-típusok használatával közvetlenül access az Blob storage eseményindító által biztosított mögöttes BlobClient objektumot:

import azure.functions as func
import azurefunctions.extensions.bindings.blob as blob

app = func.FunctionApp(http_auth_level=func.AuthLevel.FUNCTION)
@app.blob_trigger(
    arg_name="client", path="PATH/TO/BLOB", connection="AzureWebJobsStorage"
)
def blob_trigger(client: blob.BlobClient):
    logging.info(
        f"Python blob trigger function processed blob \n"
        f"Properties: {client.get_blob_properties()}\n"
        f"Blob content head: {client.download_blob().read(size=1)}"
    )

Más SDK-típusok használatára vonatkozó példákért lásd a ContainerClient és StorageStreamDownloader mintákat. Az SDK típusú kötések függvényalkalmazásba való belefoglalásáról részletes oktatóanyagot a Pikon SDK-kötések blobmintához.

További információkért, beleértve a többi SDK-típusú kötést is, tekintse meg az SDK-típuskötéseket.

Ez a példa naplózza a blob nevét és méretét a bejövő blob-eseményindítóból.

import logging
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="BlobTrigger1")
@app.blob_trigger(arg_name="myblob", 
                  path="samples-workitems/{name}",
                  connection="MyStorageAccountAppSetting")
def test_function(myblob: func.InputStream):
   logging.info(f"Python blob trigger function processed blob \n"
                f"Name: {myblob.name}\n"
                f"Blob Size: {myblob.length} bytes")

Az alábbi példa egy Blob Storage trigger függvényt mutat, amely feltöltött blobokat dolgozza fel:

package main

import (
	"context"
	"fmt"
	"io"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/blob"
	"github.com/azure/azure-functions-golang-worker/sdk"
	_ "github.com/azure/azure-functions-golang-worker/triggers/blob"
	"github.com/azure/azure-functions-golang-worker/worker"
)

func main() {
	app := sdk.FunctionApp()
	app.Blob("blobTrigger", processBlob,
		sdk.WithPath("samples-workitems/{name}"),
		sdk.WithConnection("AzureWebJobsStorage"),
	)
	worker.Start(app)
}

func processBlob(ctx context.Context, client *blob.Client) error {
	get, err := client.DownloadStream(ctx, nil)
	if err != nil {
		return fmt.Errorf("download error: %w", err)
	}
	data, _ := io.ReadAll(get.Body)
	get.Body.Close()
	log.Printf("Go Blob trigger function processed blob, %d bytes", len(data))
	return nil
}

Megjegyzés:

A Go Blob trigger közvetlenül a kezelőnek autentikált Azure SDK *blob.Client-t biztosít. Hozzá kell adnod egy üres importot , triggers/blob hogy a Blob trigger csomag elérhetővé váljon a Go dolgozó számára.

Attribútumok

A in-process és végző feldolgozói folyamat C#-kódtárak a BlobAttribute attribútumot használják a függvény definiálásához. A C#-szkript ehelyett egy function.json konfigurációs fájlt használ a C#-szkriptelési útmutatóban leírtak szerint.

Az attribútum konstruktora a következő paramétereket veszi fel:

Paraméter Leírás
BlobPath A blob elérési útja.
Kapcsolat Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat Azure blobokhoz. Lásd: Kapcsolatok.
Access Azt jelzi, hogy olvas vagy ír.
Forrás Beállítja az eseményindító esemény forrását. BlobTriggerSource.EventGrid használható, amely kisebb késést biztosít. Az alapértelmezett beállítás az BlobTriggerSource.LogsAndContainerScan, amely a szabványos lekérdezési mechanizmust használja a tároló változásainak észlelésére.

Íme egy BlobTrigger attribútum egy metódus-aláírásban:

[Function(nameof(BlobFunction))]
[BlobOutput("test-samples-output/{name}-output.txt")]
public static string Run(
    [BlobTrigger("test-samples-trigger/{name}")] string myTriggerItem,
    [BlobInput("test-samples-input/sample1.txt")] string myBlob,
    FunctionContext context)

Helyi fejlesztéskor adja hozzá az alkalmazásbeállításokat a gyűjtemény local.settings.json fájljáhozValues.

Dekorátorok

Csak a Python v2 programozási modellre vonatkozik.

A dekorátorokkal definiált Python v2-függvények esetében a blob_trigger dekorátor következő tulajdonságai határozzák meg a Blob Storage eseményindítót:

Tulajdonság Leírás
arg_name Deklarálja a paraméter nevét a függvény-aláírásban. A függvény aktiválásakor ennek a paraméternek az értéke tartalmazza az üzenetsor-üzenet tartalmát.
path A figyelendő container. Lehet, hogy blobnévminta.
connection A storage fiók kapcsolati karakterlánc.
source Beállítja az eseményindító esemény forrását. EventGrid használható, amely kisebb késést biztosít. Az alapértelmezett beállítás az LogsAndContainerScan, amely a szabványos lekérdezési mechanizmust használja a tároló változásainak észlelésére.

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

Jegyzetek

A @BlobTrigger attribútum segítségével access adhat a függvényt aktiváló blobnak. Részletekért tekintse meg az eseményindító példáját . source A tulajdonság használatával állítsa be az eseményindító esemény forrását. EventGrid használható, amely kisebb késést biztosít. Az alapértelmezett beállítás az LogsAndContainerScan, amely a szabványos lekérdezési mechanizmust használja a tároló változásainak észlelésére. |

Konfiguráció

Csak a Python v1 programozási modellre vonatkozik.

Az alábbi táblázat a metódusnak options átadott objektumon app.storageBlob() beállítható tulajdonságokat ismerteti.

Tulajdonság Leírás
ösvény A figyelendő container. Lehet, hogy blobnévminta.
kapcsolat Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat Azure blobokhoz. Lásd: Kapcsolatok.
forrás Beállítja az eseményindító esemény forrását. EventGrid használható, amely kisebb késést biztosít. Az alapértelmezett beállítás az LogsAndContainerScan, amely a szabványos lekérdezési mechanizmust használja a tároló változásainak észlelésére.

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság Leírás
típus A beállításnak a blobTriggerkövetkezőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót a Azure portal.
irány A beállításnak a inkövetkezőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza az eseményindítót a Azure portal. A használati szakaszban kivételeket jegyezünk fel.
név Annak a változónak a neve, amely a függvénykódban a blobot jelöli.
ösvény A figyelendő container. Lehet, hogy blobnévminta.
kapcsolat Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat Azure blobokhoz. Lásd: Kapcsolatok.
forrás Beállítja az eseményindító esemény forrását. EventGrid használható, amely kisebb késést biztosít. Az alapértelmezett beállítás az LogsAndContainerScan, amely a szabványos lekérdezési mechanizmust használja a tároló változásainak észlelésére.

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

Tipp.

Egy teljes munkapéldát, amely egy Event Grid-alapú blob-eseményindítót használ kapcsolati, forrás- és kimeneti kötéskonfigurációval, tekintse meg a Respond to blob storage events using Azure Functions.

Metaadatok

A blob-eseményindító számos metaadat-tulajdonságot biztosít. Ezek a tulajdonságok a kötési kifejezések részeként használhatók más kötésekben vagy a kód paramétereiként. Ezek az értékek ugyanolyan szemantikával rendelkeznek, mint a CloudBlob típus.

Tulajdonság Típus Leírás
BlobTrigger string Az eseményindító blob elérési útja.
Uri System.Uri Az elsődleges hely blobjának URI-ja.
Properties BlobProperties A blob rendszertulajdonságai.
Metadata IDictionary<string,string> A blob felhasználó által definiált metaadatai.

Az alábbi példa naplózza az eseményindító blob elérési útját, beleértve a tárolót is:

public static void Run(string myBlob, string blobTrigger, ILogger log)
{
    log.LogInformation($"Full blob path: {blobTrigger}");
}

Metaadatok

A blob-eseményindító számos metaadat-tulajdonságot biztosít. Ezek a tulajdonságok a kötési kifejezések részeként használhatók más kötésekben vagy a kód paramétereiként.

Tulajdonság Leírás
blobTrigger Az eseményindító blob elérési útja.
uri Az elsődleges hely blobjának URI-ja.
properties A blob rendszertulajdonságai.
metadata A blob felhasználó által definiált metaadatai.

A metaadatok a triggerMetadata megadott context objektum tulajdonságából kérhetők le, ahogyan az alábbi példában látható, amely naplózza az eseményindító blob elérési útját (blobTriggerbeleértve a tárolót is):

context.log(`Full blob path: ${context.triggerMetadata.blobTrigger}`);

Metaadatok

A metaadatok a $TriggerMetadata paraméteren keresztül érhetők el.

Használat

A Blob-eseményindító által támogatott kötéstípusok a bővítménycsomag verziójától és a függvényalkalmazásban használt C# módtól függnek.

A blob-eseményindító a következő típusokhoz tud kapcsolódni:

Típus Leírás
string A blob tartalma sztringként. Akkor használható, ha a blob tartalma egyszerű szöveg.
byte[] A blobtartalom bájtja.
JSON szerializálható típusok Ha egy blob JSON-adatokat tartalmaz, a Functions megpróbálja deszerializálni a JSON-adatokat egy egyszerű régi CLR-objektum (POCO) típusba.
Stream1 A blobtartalom bemeneti adatfolyama.
BlobClient1,
BlockBlobClient1,
PageBlobClient1,
AppendBlobClient1,
BlobBaseClient1		 A blobhoz csatlakoztatott ügyfél. Ez a típuskészlet biztosítja a blob feldolgozásának legnagyobb vezérlését, és a blobba való visszaírásra is használható, ha a kapcsolat megfelelő engedéllyel rendelkezik.

1 Az ilyen típusok használatához Microsoftra kell hivatkoznia. Azure. Functions.Worker.Extensions. Storage. Blobok 6.0.0 vagy újabb és az SDK-típuskötések common függőségei.

Kötés a stringblob méretéhez, vagy Byte[] csak akkor ajánlott, ha a blob mérete kicsi. Ez azért ajánlott, mert a blob teljes tartalma betöltődik a memóriába. A legtöbb blobhoz használjon vagy írjon be egy típust StreamBlobClient . További információ: Konkurencia és memóriahasználat.

Ha hibaüzenet jelenik meg az SDK egyik Storage típusához való kötéskor, győződjön meg arról, hogy rendelkezik A megfelelő Storage SDK-verzióra.

A StorageAccountAttribute használatával is megadhatja a használni kívánt storage fiókot. Ezt akkor teheti meg, ha más storage fiókot kell használnia, mint a tár más funkcióit. A konstruktor egy storage kapcsolati karakterlánc tartalmazó alkalmazásbeállítás nevét veszi fel. Az attribútum a paraméter, a metódus vagy az osztály szintjén alkalmazható. Az alábbi példa az osztályszintet és a metódusszintet mutatja be:

[StorageAccount("ClassLevelStorageAppSetting")]
public static class AzureFunctions
{
    [FunctionName("BlobTrigger")]
    [StorageAccount("FunctionLevelStorageAppSetting")]
    public static void Run( //...
{
    ....
}

A használni kívánt storage fiók meghatározása a következő sorrendben történik:

  • Az BlobTrigger attribútum tulajdonsága Connection .
  • Az StorageAccount attribútummal azonos paraméterre BlobTrigger alkalmazott attribútum.
  • A StorageAccount függvényre alkalmazott attribútum.
  • Az StorageAccount osztályra alkalmazott attribútum.
  • A függvényalkalmazás alapértelmezett storage fiókja, amely a AzureWebJobsStorage alkalmazásbeállításban van definiálva.

Megjegyzés:

Az SDK-típusokhoz való kötés támogatása jelenleg előzetes verzióban érhető el, és a Azure Blob Storage SDK-ra korlátozódik. További információ: SDK-típusok a Java-referenciacikkben.

Access a blobadatokat a függvény első argumentumaként.

Access blobadatokat egy olyan paraméteren keresztül, amely megfelel a kötés névparamétere által a function.json fájlban megadott névnek.

Access blobadatokat a InputStream paraméteren keresztül. Részletekért tekintse meg az eseményindító példáját .

A Functions támogatja a Python SDK-típuskötéseket Azure Blob storage esetében is, amely lehetővé teszi a blobadatok használatát az alábbi mögöttes SDK-típusok használatával:

Megjegyzés:

Csak a szinkron SDK-típusok támogatottak.

Fontos

A Python SDK-típusok támogatása általánosan elérhető, és csak a Python v2 programozási modell esetében támogatott. További információ: SDK-típusok a Pythonban.

Kapcsolatok

A connection tulajdonság a környezeti konfigurációra mutató hivatkozás, amely meghatározza, hogy az alkalmazás hogyan csatlakozzon Azure blobokhoz. A következőt határozhatja meg:

  • Egy kapcsolati karakterlánc
  • Egy megosztott előtag neve több alkalmazásbeállításhoz, valamint identitásalapú kapcsolat definiálása.

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.

Csatlakozási karakterlánc

A kapcsolati karakterlánc beszerzéséhez kövesse a A fiók storage access kulcsok című témakörben ismertetett lépéseket. A kapcsolati karakterlánc általános célú storage fióknak kell lennie, nem pedig Blob storage fióknak.

Ezt a kapcsolati karakterlánc egy olyan alkalmazásbeállításban kell tárolni, amely a kötéskonfiguráció connection tulajdonsága által megadott értéknek megfelelő névvel rendelkezik.

Ha az alkalmazásbeállítás neve az "AzureWebJobs" névvel kezdődik, itt csak a név fennmaradó részét adhatja meg. Ha például a "MyStorage" értékre van állítva connection , a Functions-futtatókörnyezet egy "AzureWebJobsMyStorage" nevű alkalmazásbeállítást keres. Ha üresen hagyja connection, a Functions-futtatókörnyezet az alapértelmezett Storage kapcsolati karakterlánc használja a AzureWebJobsStorage nevű alkalmazásbeállításban.

Identitásalapú kapcsolatok

Ha version 5.x vagy újabb bővítményt használ (bundle 3.x vagy újabb nem .NET nyelvi verem esetén), ahelyett, hogy titkos kapcsolati karakterlánc használ, az alkalmazás használhat egy Microsoft Entra-identitást. Identitás használatához olyan beállításokat kell megadnia egy közös előtag alatt, amely leképezi a tulajdonságot az connection eseményindító és a kötés konfigurációjában.

Ha connection az "AzureWebJobsStorage" értékre állítja, tekintse meg Kapcsolódás identitással rendelkező storage üzemeltetéséhez. Az összes többi kapcsolat esetében 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
Blob Service URI <CONNECTION_NAME_PREFIX>__serviceUri 1 Annak a blobszolgáltatásnak az adatsíkja, amelyhez csatlakozik, a HTTPS-séma használatával. <https://storage_account_name.blob.core.windows.net>

Az 1<CONNECTION_NAME_PREFIX>__blobServiceUri aliasként használható. Ha a kapcsolatkonfigurációt egy blob-eseményindító fogja használni, blobServiceUri azt is mellékelnie queueServiceUrikell. Lásd alább.

Az serviceUri űrlap nem használható, ha az általános kapcsolatkonfigurációt blobokon, üzenetsorokon és/vagy táblákon kell használni. Az URI csak a blobszolgáltatást tudja kijelölni. Alternatív megoldásként külön URI-t is megadhat az egyes szolgáltatásokhoz, így egyetlen kapcsolat használható. Ha mindkét verzió meg van adva, a rendszer a többszolgáltatásos űrlapot használja. Több szolgáltatás kapcsolatának konfigurálásához a következő helyett <CONNECTION_NAME_PREFIX>__serviceUriállítsa be a következőt:

Tulajdonság Környezeti változó sablonja Leírás Példaérték
Blob Service URI <CONNECTION_NAME_PREFIX>__blobServiceUri Annak a blobszolgáltatásnak az adatsíkja, amelyhez csatlakozik, a HTTPS-séma használatával. <https://storage_account_name.blob.core.windows.net>
Queue Service URI (a 2. blob triggerekhezszükséges) <CONNECTION_NAME_PREFIX>__queueServiceUri Egy üzenetsor-szolgáltatás adatsíkjának URI-ja a HTTPS-séma használatával. Ez az érték csak a blob-eseményindítókhoz szükséges. <https://storage_account_name.queue.core.windows.net>

2 A blob-eseményindító több újrapróbálkozást is kezel, ha poison blobokat ír egy üzenetsorba. serviceUri Az űrlapon a rendszer a AzureWebJobsStorage kapcsolatot használja. A beállításkor blobServiceUriazonban egy üzenetsor-szolgáltatás URI-jának is meg kell adni.queueServiceUri Javasoljuk, hogy a szolgáltatást a blobszolgáltatással azonos storage fiókból használja. Arról is gondoskodnia kell, hogy az eseményindító képes legyen üzeneteket olvasni és írni a konfigurált üzenetsor-szolgáltatásban egy olyan szerepkör hozzárendelésével, mint Storage Üzenetsor-adatszolgáltató.

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

Felhasználó által hozzárendelt felügyelt identitás

Felhasználó által hozzárendelt felügyelt identitás használatához adja hozzá a credential szolgáltatás URI-ja mellett a tulajdonságokat és clientId a tulajdonságokat:

Tulajdonság Környezeti változó sablonja Leírás Példaérték
Blob Service URI <CONNECTION_NAME_PREFIX>__blobServiceUri A blobszolgáltatás adatsíkjának URI-ja. https://mystorageaccount.blob.core.windows.net
Üzenetsor-szolgáltatás URI-ja <CONNECTION_NAME_PREFIX>__queueServiceUri A várólista-szolgáltatás adatsíkjának URI-ja (blob-eseményindítókhoz szükséges). https://mystorageaccount.queue.core.windows.net
Credential <CONNECTION_NAME_PREFIX>__credential A beállításnak a managedidentitykövetkezőnek kell lennie: . managedidentity
Ügyfélazonosító <CONNECTION_NAME_PREFIX>__clientId A felhasználó által hozzárendelt felügyelt identitás ügyfélazonosítója. 00000000-0000-0000-0000-000000000000

Ha például a kötéskonfigurációt connection = "BlobStorageConnection"adja meg, a következő alkalmazásbeállításokat konfigurálhatja:

{
    "BlobStorageConnection__blobServiceUri": "https://mystorageaccount.blob.core.windows.net",
    "BlobStorageConnection__queueServiceUri": "https://mystorageaccount.queue.core.windows.net",
    "BlobStorageConnection__credential": "managedidentity",
    "BlobStorageConnection__clientId": "00000000-0000-0000-0000-000000000000"
}

Tipp.

A felhasználó által hozzárendelt felügyelt identitások olyan éles helyzetekben ajánlottak, ahol több erőforrás identitásengedélyeinek részletes szabályozására van szükség.

A Azure Functions szolgáltatásban üzemeltetett identitásalapú kapcsolatok managed 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 assign szerepkört kell hozzárendelnie Azure RBAC 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.

Létre kell hoznia egy szerepkör-hozzárendelést, amely futásidőben access biztosít a blobtárolónak. Az olyan felügyeleti szerepkörök, mint a Owner nem elegendőek. Az alábbi táblázat a Blob Storage bővítmény normál műveletben való használatakor ajánlott beépített szerepköröket mutatja be. 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ökre
Eseményindító Storage blobadatok tulajdonosaandStorage Üzenetsoradat-közreműködő1

További engedélyeket is meg kell adni az AzureWebJobsStorage-kapcsolatnak.2
Bemeneti kötés Storage Blob-adatolvasó
Kimeneti kötés Storage Blob-adattulajdonos

1 A blob-eseményindító több újrapróbálkozási művelet során is kezeli a hibákat, ha poison blobokat ír a kapcsolat által megadott storage-fiók egyik üzenetsorába.

2 Az AzureWebJobsStorage kapcsolat belsőleg használatos az eseményindítót engedélyező blobokhoz és üzenetsorokhoz. Ha identitásalapú kapcsolat használatára van konfigurálva, az alapértelmezett követelményen túl további engedélyekre van szüksége. A szükséges engedélyekre a Storage Blob-adattulajdonos, Storage üzenetsoradat-közreműködő és Storage fiók közreműködője szerepkör vonatkozik. További információ: Kapcsolódás a storage identitással rendelkező gazdagéphez.

Blobnévminták

Blobnévmintát path a function.json tulajdonságában vagy az BlobTrigger attribútumkonstruktorban adhat meg. A névminta lehet szűrő vagy kötési kifejezés. A következő szakaszok példákat mutatnak be.

Tipp.

A tárolónevek nem tartalmazhatnak feloldót a névmintában.

Fájlnév és -bővítmény lekérése

Az alábbi példa bemutatja, hogyan lehet külön kapcsolódni a blobfájl nevéhez és bővítményéhez:

"path": "input/{blobname}.{blobextension}",

Ha a blob neve original-Blob1.txt, akkor a függvénykódban szereplő blobname értékek és blobextension változók értéke original-Blob1 és txt.

Szűrés blobnév alapján

Az alábbi példa csak az input "original-" sztringgel kezdődő tárolóban lévő blobokon aktiválódik:

"path": "input/original-{name}",

Ha a blob neve original-Blob1.txt, a name függvénykód változójának értéke .Blob1.txt

Szűrés fájltípusra

Az alábbi példa csak .png fájlokon aktiválódik:

"path": "samples/{name}.png",

Szűrés a kapcsos zárójelekre a fájlnevekben

Ha kapcsos zárójeleket szeretne keresni a fájlnevekben, két kapcsos zárójel használatával meneküljön el a kapcsos zárójelek elől. Az alábbi példa azokra a blobokra szűr, amelyek nevében kapcsos zárójelek vannak:

"path": "images/{{20140101}}-{name}",

Ha a blob neve {20140101}-soundfile.mp3, a name függvénykód változóértéke soundfile.mp3.

Lekérdezés és késés

A lekérdezés hibridként működik a naplók vizsgálata és az időszakos tárolóvizsgálatok futtatása között. A blobokat egyszerre 10 000-ből álló csoportokban ellenőrzi a rendszer, és az intervallumok között egy folytatási jogkivonatot használ. Ha a függvényalkalmazás a Használat csomagban található, akár 10 perces késés is előfordulhat az új blobok feldolgozásában, ha egy függvényalkalmazás inaktív állapotba került.

Figyelmeztetés

Storage naplók a "legjobb munka" alapján jönnek létre. Nincs garancia arra, hogy minden esemény rögzítve van. Bizonyos feltételek mellett előfordulhat, hogy a naplók kimaradnak.

Ha gyorsabb vagy megbízhatóbb blobfeldolgozásra van szüksége, érdemes úgy váltania a tárhelyét, hogy egy App Service csomagot használjon Always On engedélyezve, ami megnövelheti a költségeket. Érdemes lehet a klasszikus lekérdezési blob-eseményindítótól eltérő eseményindítót is használni. További információkért és a blob storage tárolók különböző triggerelési beállításainak összehasonlításáért lásd: Tragger egy blobtárolón.

Blobok nyugtái

A Azure Functions futtatókörnyezet biztosítja, hogy egyetlen blob triggerfüggvényét sem hívja meg többször ugyanarra az új vagy frissített blobra. Annak megállapításához, hogy egy adott blobverzió feldolgozásra került-e, a blob nyugtáit tartja-e fenn.

Azure Functions a blobok nyugtáit egy azure-webjobs-hosts nevű tárolóban tárolja a függvényalkalmazás Azure storage fiókjában (az alkalmazásbeállítás AzureWebJobsStorage). A blobok nyugtázása a következő információkkal rendelkezik:

  • Az aktivált függvény (<FUNCTION_APP_NAME>.Functions.<FUNCTION_NAME>például: MyFunctionApp.Functions.CopyBlob)
  • A tároló neve
  • A blob típusa (BlockBlob vagy PageBlob)
  • A blob neve
  • Az ETag (egy blobverzió azonosítója, például: 0x8D1DC6E70A277EF)

A blob újrafeldolgozásának kényszerítéséhez törölje a blobhoz tartozó blob nyugtát a azure-webjobs-hosts tárolóból manuálisan. Előfordulhat, hogy az újrafeldolgozás nem történik meg azonnal, de ez garantáltan egy későbbi időpontban történik. Az azonnali feldolgozáshoz a scaninfo blob frissíthető azure-webjobs-hosts/blobscaninfo. A tulajdonság ismételt vizsgálata után LatestScan az utolsó módosított időbélyeggel rendelkező blobok.

Mérgező blobok

Ha egy blob triggerfüggvénye meghiúsul egy adott blob esetében, Azure Functions alapértelmezés szerint ötször újrapróbálkozza a függvényt.

Ha mind az öt próbálkozás sikertelen, Azure Functions egy Storage webjobs-blobtrigger-poison nevű üzenetsorhoz ad hozzá üzenetet. Az újrapróbálkozések maximális száma konfigurálható. Ugyanez a MaxDequeueCount beállítás használatos a méregblobok kezeléséhez és a méregsor üzenetkezeléséhez. A méregblobok üzenetsor-üzenete egy JSON-objektum, amely a következő tulajdonságokat tartalmazza:

  • FunctionId (formátum <FUNCTION_APP_NAME>.Functions.<FUNCTION_NAME>)
  • BlobType (BlockBlob vagy PageBlob)
  • KonténerNév
  • BlobName
  • ETag (blobverzió azonosítója, például: 0x8D1DC6E70A277EF)

Memóriahasználat és egyidejűség

Ha olyan kimeneti típushoz kötődik, amely nem támogatja a streamelést, például stringa Byte[]futtatókörnyezetnek a teljes blobot többször kell betöltenie a memóriába a feldolgozás során. Ez a blobok feldolgozásakor a vártnál nagyobb memóriahasználatot eredményezhet. Ha lehetséges, használjon stream-támogató típust. A típustámogatás a C# módtól és a bővítmény verziójától függ. További információ: Binding típusok.

Jelenleg a futtatókörnyezetnek a teljes blobot többször kell betöltenie a memóriába a feldolgozás során. Ez a blobok feldolgozásakor a vártnál nagyobb memóriahasználatot eredményezhet.

A memóriahasználat további hatással lehet, ha több függvénypéldány egyidejűleg blobadatokat dolgoz fel. Ha memóriaproblémák merülnek fel egy Blob-eseményindító használatával, fontolja meg az egyidejű végrehajtások számának csökkentését. Az egyidejűség csökkentése a feldolgozásra váró blobok hátralékának növelését okozhatja. A függvényalkalmazás memóriakorlátja a tervtől függ. További információ: Szolgáltatáskorlátok.

Az egyidejű végrehajtások számának szabályozása a használt Storage bővítmény verziójától függ.

A Storage bővítmény vagy egy újabb verzió 5.0.0-s verziójának használatakor az eseményindító egyidejűségét a maxDegreeOfParallelism beállításával szabályozhatja.

A blob-eseményindítót használó függvényekre külön-külön vonatkoznak a korlátozások.

host.json tulajdonságok

A host.json fájl olyan beállításokat tartalmaz, amelyek szabályozzák a blobok eseményindítójának viselkedését. Az elérhető beállításokról a host.json beállítások szakaszban olvashat.

Következő lépések

  • Last updated on