Azure Blob storage trigger for Azure Functions

O modelo de programação Python v2 permite definir ligações usando decoradores diretamente em seu código de função Python. Para obter mais informações, consulte o guia do desenvolvedor do Python.

O modelo de programação Python v1 requer que você defina ligações em um arquivo function.json separado na pasta de funções. Para obter mais informações, consulte o guia do desenvolvedor do Python.

O exemplo a seguir é uma função C# que é executada em um processo de trabalho isolado e usa um gatilho de blob com ligações de blob de entrada e saída de blob. A função é acionada pela criação de um blob no contêiner test-samples-trigger . Ele lê um arquivo de texto do contêiner test-samples-input e cria um novo arquivo de texto em um contêiner de saída com base no nome do arquivo acionado.

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

O exemplo a seguir mostra uma samples-workitems C# que grava um log quando um blob é adicionado ou atualizado no contêiner.

[FunctionName("BlobTriggerCSharp")]        
public static void Run([BlobTrigger("samples-workitems/{name}")] Stream myBlob, string name, ILogger log)
{
    log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");
}

A string {name} no caminho do blob trigger samples-workitems/{name} cria uma expressão binding que podes usar em código de função para access o nome do ficheiro do blob que disparou. Para obter mais informações, consulte Padrões de nome de blob mais adiante neste artigo.

Para obter mais informações sobre o BlobTrigger atributo, consulte Atributos.

Este exemplo mostra como obter o BlobClient tanto de um Storage Blob trigger como da ligação de entrada num trigger HTTP:

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

Este exemplo mostra como obter o ContainerClient tanto de uma ligação de entrada Storage Blob usando um trigger HTTP:

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

O exemplo a seguir mostra um código TypeScript de gatilho de blob. A função grava um log quando um blob é adicionado ou atualizado no samples-workitems contêiner.

A string {name} no caminho do blob trigger samples-workitems/{name} cria uma expressão binding que podes usar em código de função para access o nome do ficheiro do blob que disparou. Para obter mais informações, consulte Padrões de nome de blob mais adiante neste artigo.

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

Os exemplos de TypeScript não estão documentados para o modelo v3.

O exemplo a seguir mostra um código JavaScript de gatilho de blob. A função grava um log quando um blob é adicionado ou atualizado no samples-workitems contêiner.

A string {name} no caminho do blob trigger samples-workitems/{name} cria uma expressão binding que podes usar em código de função para access o nome do ficheiro do blob que disparou. Para obter mais informações, consulte Padrões de nome de blob mais adiante neste artigo.

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

O exemplo a seguir mostra uma ligação de gatilho de blob em um arquivo function.json e código JavaScript que usa a ligação. A função grava um log quando um blob é adicionado ou atualizado no samples-workitems contêiner.

Aqui está o arquivo function.json :

{
    "disabled": false,
    "bindings": [
        {
            "name": "myBlob",
            "type": "blobTrigger",
            "direction": "in",
            "path": "samples-workitems/{name}",
            "connection":"MyStorageAccountAppSetting"
        }
    ]
}

A string {name} no caminho do blob trigger samples-workitems/{name} cria uma expressão binding que podes usar em código de função para access o nome do ficheiro do blob que disparou. Para obter mais informações, consulte Padrões de nome de blob mais adiante neste artigo.

Para obter mais informações sobre function.json propriedades do arquivo, consulte a seção Configuração explica essas propriedades.

Aqui está o código JavaScript:

module.exports = async function(context) {
    context.log('Node.js Blob trigger function processed', context.bindings.myBlob);
};

Este exemplo usa tipos SDK para access diretamente o objeto subjacente BlobClient fornecido pelo gatilho Blob storage:

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

Para exemplos de utilização de outros tipos de SDK, veja as amostras ContainerClient e StorageStreamDownloader. Para um tutorial passo a passo sobre como incluir bindings do tipo SDK na sua aplicação de funções, siga as associações SDK Python para Blob Sample.

Para saber mais, incluindo quais outras associações de tipo SDK são suportadas, consulte Associações de tipo SDK.

Este exemplo regista o nome e o tamanho do blob a partir do gatilho do blob recebido.

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

A função escreve um log quando um blob é adicionado ou atualizado no samples-workitemscontainer. Aqui está o arquivo function.json :

{
    "scriptFile": "__init__.py",
    "disabled": false,
    "bindings": [
        {
            "name": "myblob",
            "type": "blobTrigger",
            "direction": "in",
            "path": "samples-workitems/{name}",
            "connection":"MyStorageAccountAppSetting"
        }
    ]
}

A string {name} no caminho do blob trigger samples-workitems/{name} cria uma expressão binding que podes usar em código de função para access o nome do ficheiro do blob que disparou. Para obter mais informações, consulte Padrões de nome de blob mais adiante neste artigo.

Para obter mais informações sobre function.json propriedades do arquivo, consulte a seção Configuração explica essas propriedades.

Aqui está o código Python:

import logging
import azure.functions as func


def main(myblob: func.InputStream):
    logging.info('Python Blob trigger function processed %s', myblob.name)

Aqui está um BlobTrigger atributo em uma assinatura de método:

[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)

Nas bibliotecas de classes C#, o construtor do atributo usa uma cadeia de caracteres de caminho que indica o contêiner a ser observado e, opcionalmente, um padrão de nome de blob. Eis um exemplo:

[FunctionName("ResizeImage")]
public static void Run(
  [BlobTrigger("sample-images/{name}")] Stream image,
  [Blob("sample-images-md/{name}", FileAccess.Write)] Stream imageSmall)
{
  ....
}

Embora o atributo tenha a propriedade Connection, também pode usar o StorageAccountAttribute para especificar uma ligação storage conta. Podes fazer isto quando precisares de usar uma conta de storage diferente das outras funções na biblioteca. O construtor assume o nome de uma definição de aplicação que contém uma storage connection string. O atributo pode ser aplicado no nível de parâmetro, método ou classe. O exemplo a seguir mostra o nível da classe e o nível do método:

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

A conta de storage a utilizar é determinada pela seguinte ordem:

• A propriedade do atributo trigger ou de ligação Connection .
• O StorageAccount atributo aplicado ao mesmo parâmetro que o atributo trigger ou de ligação.
• O StorageAccount atributo aplicado à função.
• O StorageAccount atributo aplicado à classe.
• A storage padrão tem em conta a aplicação funcional, que está definida na configuração AzureWebJobsStorage da aplicação.

A tabela a seguir explica as propriedades que você pode definir no options objeto passado para o app.storageBlob() método.

A tabela a seguir explica as propriedades de configuração de associação definidas no arquivo function.json .

Os metadados podem ser obtidos da triggerMetadata propriedade do objeto fornecido context , conforme mostrado no exemplo a seguir, que registra o caminho para o blob de acionamento (blobTrigger), incluindo o contêiner:

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

Os metadados podem ser obtidos da bindingData propriedade do objeto fornecido context , conforme mostrado no exemplo a seguir, que registra o caminho para o blob de acionamento (blobTrigger), incluindo o contêiner:

module.exports = async function (context, myBlob) {
    context.log("Full blob path:", context.bindingData.blobTrigger);
};

O gatilho de blob pode se ligar aos seguintes tipos:

¹ Para usar estes tipos, precisa de consultar Microsoft. Azure. Funções.Trabalhadores.Extensões. Storage. Blobs 6.0.0 ou posterior e as dependências common para ligações de tipos SDK.

Consulte Tipos de ligação para uma lista de tipos suportados.

Acess os dados do blob como primeiro argumento para a tua função.

Access dados de blob usando context.bindings.<NAME> onde <NAME> corresponde ao valor definido em function.json.