Tutorial: Ativar funções Azure em contentores de blob usando uma subscrição de evento

As versões anteriores do Armazenamento de Blob do Azure Functions acionam a sondagem do contêiner de armazenamento em busca de alterações. Versões mais recentes da extensão Blob Storage (5.x+) passaram a utilizar uma subscrição de eventos Event Grid no 'container'. Esta subscrição de eventos reduz a latência ao acionar a sua função instantaneamente à medida que ocorrem alterações no contentor subscrito.

Este artigo mostra como criar uma função que é executada com base em eventos gerados quando um blob é adicionado a um contêiner. Você usa o Visual Studio Code para desenvolvimento local e para validar seu código antes de implantar seu projeto no Azure.

Crie uma função acionada de Blob Storage baseada em eventos em um novo projeto.
Valida localmente dentro do Visual Studio Code usando o emulador Azurite.
Crie um contêiner de armazenamento de blob em uma nova conta de armazenamento no Azure.
Crie um aplicativo de função no plano Flex Consumption.
Crie uma assinatura de evento para o novo contêiner de blob.
Implante e valide seu código de função no Azure.

Este artigo suporta a versão 4 do modelo de programação Node.js para o Azure Functions.

Este artigo suporta a versão 2 do modelo de programação Python para o Azure Functions.

Este artigo cria um aplicativo C# que é executado no modo de trabalho isolado, que oferece suporte ao .NET 8.0.

Gorjeta

Este tutorial mostra como criar um aplicativo que é executado no plano Flex Consumption. O plano Flex Consumption suporta apenas a versão baseada em eventos do gatilho de Armazenamento de Blob.

Pré-requisitos

Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
SDK do .NET 8.0.
Visual Studio Code numa das plataformas suportadas.
Extensão C# para Visual Studio Code.
Extensão do Azure Functions para Visual Studio Code.

Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
Node.js 14.x ou superior. Use o node --version comando para verificar sua versão.
Visual Studio Code numa das plataformas suportadas.
A extensão das Funções do Azure para o Visual Studio Code. Esta extensão instala as Ferramentas Principais do Azure Functions para você na primeira vez que executar localmente suas funções.

Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
PowerShell 7.2
Tempo de execução do .NET 6.0
Visual Studio Code numa das plataformas suportadas.
A extensão do PowerShell para Visual Studio Code.
A extensão das Funções do Azure para o Visual Studio Code.

Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
Versões Python suportadas pelo Azure Functions. Para obter mais informações, consulte Como instalar o Python.
Visual Studio Code numa das plataformas suportadas.
A extensão Python para Visual Studio Code.
A extensão das Funções do Azure para o Visual Studio Code.

Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
O Java Development Kit, versão 8, 11, 17 ou 21 (Linux).
Apache Maven, versão 3.0 ou superior.
Visual Studio Code numa das plataformas suportadas.
O pacote de extensão Java
A extensão das Funções do Azure para o Visual Studio Code.

Extensão de armazenamento do Azure para Visual Studio Code.

Nota

A extensão Azure Storage para Visual Studio Code está em pré-visualização.

Criar uma função acionada por Blob

Quando crias uma função de gatilho de Armazenamento de Blob usando o Visual Studio Code, também crias um novo projeto. Você precisa editar a função para consumir uma assinatura de evento como fonte, em vez de usar o contêiner sondagem regular.

No Visual Studio Code, pressione F1 para abrir a paleta de comandos, digite Azure Functions: Create Function...e selecione Criar novo projeto.
Para o espaço de trabalho do projeto, selecione um local de diretório. Certifique-se de criar uma nova pasta ou escolher uma pasta vazia para o espaço de trabalho do projeto.

Não escolha uma pasta de projeto que já faça parte de um espaço de trabalho.

Nos prompts, forneça as seguintes informações:

Pedido	Ação
Selecione um idioma	Selecione `C#`.
Selecione um tempo de execução do .NET	Selecione `.NET 8.0 Isolated LTS`.
Selecione um modelo para a primeira função do seu projeto	Selecione `Azure Blob Storage trigger (using Event Grid)`.
Fornecer um nome de função	Introduzir `EventGridBlobTrigger`.
Fornecer um namespace	Introduzir `My.Functions`.
Selecione a configuração de "local.settings.json"	Selecione `Create new local app setting`.
Selecionar subscrição	Selecione sua assinatura, se necessário.
Selecione uma conta de armazenamento	Use o emulador Azurite para armazenamento local.
O caminho dentro da sua conta de armazenamento que o gatilho monitorará	Aceite o valor `samples-workitems`padrão .
Selecione como gostaria de abrir o seu projeto	Selecione `Open in current window`.

Pedido	Ação
Selecione um idioma	Selecione `Python`.
Selecione um modelo de programação Python	Selecione `Model V2`
Selecione um interpretador Python para criar um ambiente virtual	Selecione seu interpretador Python preferido. Se uma opção não for mostrada, insira o caminho completo para o binário do Python.
Selecione um modelo para a primeira função do seu projeto	Selecione `Blob trigger`. (O modelo baseado em evento ainda não está disponível.)
Fornecer um nome de função	Introduzir `EventGridBlobTrigger`.
O caminho dentro da sua conta de armazenamento que o gatilho monitorará	Aceite o valor `samples-workitems`padrão .
Selecione a configuração de "local.settings.json"	Selecione `Create new local app setting`.
Selecionar subscrição	Selecione sua assinatura, se necessário.
Selecione uma conta de armazenamento	Use o emulador Azurite para armazenamento local.
Selecione como gostaria de abrir o seu projeto	Selecione `Open in current window`.

Pedido	Ação
Selecione um idioma	Selecione `Java`.
Selecione uma versão do Java	Selecione `Java 11` ou `Java 8`, a versão Java na qual suas funções são executadas no Azure e que você verificou localmente.
Fornecer um ID de grupo	Selecione `com.function`.
Fornecer um ID de artefato	Selecione `EventGridBlobTrigger` (ou o padrão).
Fornecer uma versão	Selecione `1.0-SNAPSHOT`.
Forneça um nome de pacote	Selecione `com.function`.
Fornecer um nome de aplicativo	Aceite o nome gerado começando com `EventGridBlobTrigger`.
Selecione a ferramenta de construção para o projeto Java	Selecione `Maven`.
Selecione como gostaria de abrir o seu projeto	Selecione `Open in current window`.

Uma função acionada por HTTP (HttpExample) é criada para você. Você não usará essa função e deve, em vez disso, criar uma nova função.

Pedido	Ação
Selecione um idioma para o seu projeto de função	Selecione `TypeScript`.
Selecione um modelo de programação TypeScript	Selecione `Model V4`.
Selecione um modelo para a primeira função do seu projeto	Selecione `Azure Blob Storage trigger (using Event Grid)`.
Fornecer um nome de função	Introduzir `EventGridBlobTrigger`.
Selecione a configuração de "local.settings.json"	Selecione `Create new local app setting`.
Selecionar subscrição	Selecione sua assinatura, se necessário.
Selecione uma conta de armazenamento	Use o emulador Azurite para armazenamento local.
O caminho dentro da sua conta de armazenamento que o gatilho monitorará	Aceite o valor `samples-workitems`padrão .
Selecione como gostaria de abrir o seu projeto	Selecione `Open in current window`.

Pedido	Ação
Selecione um idioma para o seu projeto de função	Selecione `JavaScript`.
Selecione um modelo de programação JavaScript	Selecione `Model V4`.
Selecione um modelo para a primeira função do seu projeto	Selecione `Azure Blob Storage trigger (using Event Grid)`.
Fornecer um nome de função	Introduzir `eventGridBlobTrigger`.
Selecione a configuração de "local.settings.json"	Selecione `Create new local app setting`.
Selecionar subscrição	Selecione sua assinatura, se necessário.
Selecione uma conta de armazenamento	Use o emulador Azurite para armazenamento local.
O caminho dentro da sua conta de armazenamento que o gatilho monitorará	Aceite o valor `samples-workitems`padrão .
Selecione como gostaria de abrir o seu projeto	Selecione `Open in current window`.

Pedido	Ação
Selecione um idioma para o seu projeto de função	Selecione `PowerShell`.
Selecione um modelo para a primeira função do seu projeto	Selecione `Azure Blob Storage trigger (using Event Grid)`.
Fornecer um nome de função	Introduzir `EventGridBlobTrigger`.
Selecione a configuração de "local.settings.json"	Selecione `Create new local app setting`.
Selecionar subscrição	Selecione sua assinatura, se necessário.
Selecione uma conta de armazenamento	Use o emulador Azurite para armazenamento local.
O caminho dentro da sua conta de armazenamento que o gatilho monitorará	Aceite o valor `samples-workitems`padrão .
Selecione como gostaria de abrir o seu projeto	Selecione `Open in current window`.

Na paleta de comandos, digite Azure Functions: Create Function... e selecione EventGridBlobTrigger. Se não vir este modelo, selecione primeiro Alterar filtro>de modelo Tudo.

Nos prompts, forneça as seguintes informações:

Pedido	Ação
Forneça um nome de pacote	Selecione `com.function`.
Fornecer um nome de função	Introduzir `EventGridBlobTrigger`.
Selecione a configuração de "local.settings.json"	Selecione `Create new local app setting`.
Selecionar subscrição	Selecione a sua subscrição.
Selecione uma conta de armazenamento	Use o emulador Azurite para armazenamento local.
O caminho dentro da sua conta de armazenamento que o gatilho monitorará	Aceite o valor `samples-workitems`padrão .

Agora você tem uma função que pode ser acionada por eventos em um contêiner de Armazenamento de Blob.

Atualizar a origem do gatilho

Tens de mudar a fonte do trigger da fonte padrão do Blob (contentor polling) para uma fonte de subscrição de eventos.

Abre o ficheiro function_app.py projeto. Observa-se uma definição da função EventGridBlobTrigger com o decorador blob_trigger aplicado.

Atualize o decorador adicionando source = "EventGrid". Sua função agora deve ser algo como isto:

@app.blob_trigger(arg_name="myblob", source="EventGrid", path="samples-workitems",
                           connection="<STORAGE_ACCOUNT>") 
def EventGridBlobTrigger(myblob: func.InputStream):
logging.info(f"Python blob trigger function processed blob"
            f"Name: {myblob.name}"
            f"Blob Size: {myblob.length} bytes")

Nesta definição, source = "EventGrid" indica que uma subscrição de evento ao samples-workitems contentor de blob é usada como fonte do evento que inicia o trigger.

(Opcional) Reveja o código

Abra o ficheiro gerado EventGridBlobTrigger.cs . Vê uma definição para uma EventGridBlobTrigger função que se assemelha a esta:

[Function(nameof(EventGridBlobTriggerCSharp))]
public async Task Run([BlobTrigger("PathValue/{name}", Source = BlobTriggerSource.EventGrid, Connection = "ConnectionValue")] Stream stream, string name)
{
    using var blobStreamReader = new StreamReader(stream);
    var content = await blobStreamReader.ReadToEndAsync();
    _logger.LogInformation("C# Blob Trigger (using Event Grid) processed blob\n Name: {name} \n Data: {content}", name, content);
}

Nesta definição, Source = BlobTriggerSource.EventGrid indica que uma subscrição de evento ao contentor de blob (no exemplo PathValue) é a fonte do evento que inicia o trigger.

Abra o ficheiro gerado EventGridBlobTrigger.java . Vê uma definição para uma EventGridBlobTrigger função que se assemelha a esta:

    @FunctionName("EventGridBlobTrigger")
    @StorageAccount("<STORAGE_ACCOUNT>")
    public void run(
        @BlobTrigger(name = "content", source = "EventGrid", path = "samples-workitems/{name}", dataType = "binary") byte[] content,
        @BindingName("name") String name,
        final ExecutionContext context
    ) {
        context.getLogger().info("Java Blob trigger function processed a blob. Name: " + name + "\n  Size: " + content.length + " Bytes");
    }

Nesta definição, source = EventGrid indica que uma subscrição de evento ao samples-workitems contêiner blob é a fonte do evento que inicia o gatilho.

Na pasta, abra o EventGridBlobTriggerfunction.json arquivo e encontre uma definição de vinculação como esta com um type de blobTrigger e um source de EventGrid:

{
    "bindings": [
        {
            "name": "InputBlob",
            "type": "blobTrigger",
            "direction": "in",
            "path": "samples-workitems/{name}",
            "source": "EventGrid",
            "connection":""
        }
    ]
}

O path indica que o contentor do blob samples-workitems é a fonte do evento que aciona o disparo.

Abra o ficheiro gerado EventGridBlobTrigger.js . Vês uma definição para uma função que se assemelha a esta:

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

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

Nesta definição, um source de EventGrid indica que uma subscrição de evento no contentor de blob samples-workitems é a origem do evento que aciona o gatilho.

Abra o ficheiro gerado EventGridBlobTrigger.ts . Vês uma definição para uma função que se assemelha a esta:

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',
    source: 'EventGrid',
    handler: storageBlobTrigger1,
});

Nesta definição, um source de EventGrid indica que uma subscrição de evento para o samples-workitems contentor de blob é a fonte do evento que inicia o gatilho.

Atualizar a extensão de armazenamento

Para usar o gatilho Blob Storage baseado em Event Grid, precisa da versão 5.x ou posterior da extensão Azure Functions Storage.

Para atualizar o seu projeto para a versão de extensão necessária, execute este dotnet add package comando na janela do Terminal:

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs

Abre o host.json ficheiro do projeto e revê o extensionBundle elemento.

Se extensionBundle.version não for pelo menos 3.3.0, substitua o extensionBundle elemento por esta versão:

"extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.0.0, 5.0.0)"
}

Preparar emulação de armazenamento local

O Visual Studio Code usa o Azurite para emular os serviços de Armazenamento do Azure quando executados localmente. Use o Azurite para emular o serviço Azure Blob Storage durante o desenvolvimento e testes locais.

Se você ainda não tiver feito isso, instale a extensão Azurite v3 para Visual Studio Code.
Verifique se o ficheiro local.settings.json tem "UseDevelopmentStorage=true" definido como AzureWebJobsStorage. Esta configuração indica ao Core Tools que use o Azurite em vez de uma ligação real à conta de armazenamento quando executado localmente.
Pressione F1 para abrir a paleta de comandos, escreva Azurite: Start Blob Service, e pressione enter. Esta ação inicia o emulador do serviço Azurite Blob Storage.
Selecione o ícone do Azure na barra de atividades, expanda , clique com o botão direito do mouse em > de Blob, selecione Criar Contêiner de Blob..., insira o nome >e pressione Enter.
Expanda Blob Containers>samples-workitems e selecione Carregar arquivos....
Escolha um arquivo para carregar no contêiner emulado localmente. A sua função irá processar este ficheiro posteriormente, para verificar e depurar o código da função. Um arquivo de texto pode funcionar melhor com o código do modelo de gatilho de Blob.

Executar a função localmente

Com um arquivo no armazenamento emulado, você pode executar sua função para simular um evento gerado por uma assinatura da Grade de Eventos. As informações de evento passadas para o gatilho dependem do arquivo adicionado ao contêiner local.

Defina quaisquer pontos de interrupção e pressione F5 para iniciar seu projeto para depuração local. As Ferramentas Principais do Azure Functions devem estar em execução na janela do Terminal.
De volta à área do Azure, expanda >, clique com o botão direito do mouse na função e selecione Executar Função Agora....
Na caixa de diálogo corpo da solicitação, digite samples-workitems/<TEST_FILE_NAME>, substituindo <TEST_FILE_NAME> pelo nome do arquivo carregado no emulador de armazenamento local.
Pressione Enter para executar a função. O valor fornecido é o caminho para o blob no emulador local. Essa cadeia de caracteres é passada para o gatilho na carga útil da solicitação, que simula a carga quando uma assinatura de evento chama sua função para relatar um blob sendo adicionado ao contêiner.
Analise a saída da execução desta função. Você deve ver na saída o nome do arquivo e seu conteúdo registrado. Se você definir quaisquer pontos de interrupção, talvez seja necessário continuar a execução.

Agora que você validou com êxito seu código de função localmente, é hora de publicar o projeto em um novo aplicativo de função no Azure.

Preparar a conta de Armazenamento do Azure

As assinaturas de eventos para o Armazenamento do Azure exigem uma conta de armazenamento v2 de uso geral. Você pode usar a extensão de Armazenamento do Azure para Visual Studio Code para criar essa conta de armazenamento.

No Visual Studio Code, pressione F1 para abrir a paleta de comandos e entre Azure Storage: Create Storage Account.... Forneça essas informações quando solicitado:

Pedido	Ação
Insira o nome da nova conta de armazenamento	Forneça um nome globalmente exclusivo. Os nomes das contas de armazenamento devem ter de 3 a 24 caracteres com apenas letras minúsculas e números. Para uma identificação mais fácil, use o mesmo nome para o grupo de recursos e o nome da aplicação funcional.
Selecione um local para novos recursos	Para um melhor desempenho, escolha uma região perto de si.

A extensão cria uma conta de armazenamento v2 de uso geral com o nome que fornecer. O mesmo nome também é usado para o grupo de recursos que contém a conta de armazenamento. O gatilho de Armazenamento de Blob baseado em Grade de Eventos requer uma conta de armazenamento v2 de uso geral.

Pressione F1 novamente e, na paleta de comandos, digite Azure Storage: Create Blob Container.... Forneça essas informações quando solicitado:

Pedido	Ação
Selecione um recurso	Selecione a conta de armazenamento v2 de uso geral que você criou.
Insira um nome para o novo contêiner de blob	Insira `samples-workitems`, que é o nome do contêiner referenciado em seu projeto de código.

Seu aplicativo de função também precisa de uma conta de armazenamento para ser executado. Para simplificar, este tutorial usa a mesma conta de armazenamento para seu gatilho de blob e seu aplicativo de função. No entanto, na produção, talvez você queira usar uma conta de armazenamento separada com seu aplicativo de função. Para obter mais informações, veja Considerações de armazenamento das Funções do Azure.

Criar a aplicação de funções

Use estas etapas para criar um aplicativo de função no plano Flex Consumption. Quando aloja a sua aplicação num plano Flex Consumption, os gatilhos do Blob Storage têm de usar subscrições de eventos.

Na barra de comandos, insira Azure Functions: Criar aplicação de funções no Azure... (Avançado).

Siga as instruções e forneça esta informação:

Pedido	Seleção
Insira um nome globalmente único para a nova aplicação de funções	Digite um nome globalmente exclusivo que identifique seu novo aplicativo de função e selecione Enter. Os carateres válidos para um nome de aplicação de funções são `a-z`, `0-9` e `-`.
Selecione um plano de alojamento	Escolha o Flex Consumption, que é o plano de alojamento recomendado para alojamento serverless.
Selecione um local para novos recursos	Selecione um local em uma região perto de você ou perto de outros serviços que suas funções acessam.
Selecione uma pilha de tempo de execução	Selecione a versão de idioma que você executa localmente no momento.
Selecione um tamanho de instância	Selecione 512. Podes sempre mudar a definição do tamanho da instância para um tamanho maior mais tarde.
Introduza o número máximo de instâncias	Selecione o valor padrão de 100, que limita a escalabilidade total da sua aplicação. Também pode escolher um valor diferente entre 40 e 1.000.
Selecione um grupo de recursos	Selecione Criar novo grupo de recursos e aceite o predefinido ou introduza outro nome para o novo grupo que seja único na sua subscrição.
Selecionar tipo de autenticação de recurso	Selecione Identidade Gerida para que a sua aplicação se ligue a recursos remotos usando autenticação Microsoft Entra ID em vez de usar segredos partilhados (cadeias de ligação e chaves), que são menos seguros.
Selecione uma identidade atribuída pelo utilizador	Selecione Criar nova identidade atribuída pelo utilizador.
Selecione um local para novos recursos	Selecione a mesma região da conta de armazenamento que criou. Se por algum motivo esta região não for suportada pelo Flex Consumption Play, não é exibida. Nesse caso, escolhe uma região próxima. Para obter mais informações, consulte Exibir regiões atualmente suportadas.
Selecione uma conta de armazenamento	Escolha o nome da conta de armazenamento que você criou.
Selecione um recurso Application Insights para a sua aplicação	Escolha Create new Application Insights resource (Criar novo recurso do Application Insights) e, no prompt, forneça o nome da instância usada para armazenar dados de tempo de execução de suas funções.

Uma notificação é exibida depois que seu aplicativo de função é criado. Selecione Exibir Saída nesta notificação para exibir os resultados da criação, incluindo os recursos do Azure que você criou.

Implementar o código de função

Importante

A implantação em um aplicativo de função existente sempre substitui o conteúdo desse aplicativo no Azure.

Na paleta de comandos, insira e selecione Azure Functions: Deploy to Function App.
Selecione o aplicativo de função que você acabou de criar. Quando solicitado sobre a substituição de implantações anteriores, selecione Implantar para implantar seu código de função no novo recurso de aplicativo de função.
Quando a implantação estiver concluída, selecione Exibir Saída para exibir os resultados da criação e da implantação, incluindo os recursos do Azure que você criou. Se você perder a notificação, selecione o ícone de sino no canto inferior direito para vê-lo novamente.

Atualizar configurações do aplicativo

Como o processo de publicação não carrega automaticamente as definições de aplicação necessárias a partir do local.settings.json ficheiro, tens de as carregar para a tua aplicação de funções para que a função corra corretamente no Azure.

Na paleta de comandos, introduza Azure Functions: Download Remote Settings..., e no prompt Selecionar um recurso escolha o nome da sua aplicação de função.
Quando solicitado que a AzureWebJobsStorage configuração já existe, selecione Sim para substituir a configuração do emulador local pela cadeia de conexão da conta de armazenamento real do Azure.
local.settings.json No arquivo, substitua a configuração do emulador local pela mesma cadeia de conexão usada paraAzureWebJobsStorage.
Remova a FUNCTIONS_WORKER_RUNTIME entrada, que não é suportada em um plano Flex Consumption.
Na paleta de comandos, introduza Azure Functions: Upload Local Settings..., e no prompt Selecionar um recurso escolha o nome da sua aplicação de função.

Agora, tanto o anfitrião das Funções como o gatilho partilham a mesma conta de armazenamento.

Criar o URL do ponto de extremidade

Para criar uma assinatura de evento, você precisa fornecer à Grade de Eventos a URL do ponto de extremidade específico para relatar eventos de Armazenamento de Blob. Este URL de extensão de blob é composto por estas partes:

Parte	Exemplo
URL do aplicativo de função base	`https://<FUNCTION_APP_NAME>.azurewebsites.net`
Caminho específico do blob	`/runtime/webhooks/blobs`
Seqüência de caracteres de consulta de função	`?functionName=Host.Functions.<FUNCTION_NAME>`
Chave de acesso da extensão Blob	`&code=<BLOB_EXTENSION_KEY>`

Embora a sua aplicação se ligue à conta de armazenamento através da autenticação Microsoft Entra ID, a chave de acesso da extensão blob ajuda a proteger o webhook da extensão blob contra acessos não autorizados. Para encontrar a chave de acesso da sua extensão Blob:

No Visual Studio Code, selecione o ícone Azure na barra de Atividades. Em Recursos, expanda sua assinatura, expanda Aplicativo de função, clique com o botão direito do mouse no aplicativo de função que você criou e selecione Abrir no portal.
Em Funções no menu à esquerda, selecione Teclas do aplicativo.
Em Chaves do Sistema, selecione a chave chamada blobs_extension e copie a chave Valor.

Inclua este valor na cadeia de consulta do novo URL do endpoint.
Crie uma nova URL de ponto de extremidade para o gatilho de Armazenamento de Blob com base no exemplo a seguir:
```
https://<FUNCTION_APP_NAME>.azurewebsites.net/runtime/webhooks/blobs?functionName=Host.Functions.EventGridBlobTrigger&code=<BLOB_EXTENSION_KEY>
```
Neste exemplo, substitua <FUNCTION_APP_NAME> pelo nome do seu aplicativo de função e <BLOB_EXTENSION_KEY> pelo valor que você obteve do portal. Se você usou um nome diferente para sua função, substitua EventGridBlobTrigger por esse nome de função.

Agora você pode usar essa URL de ponto de extremidade para criar uma assinatura de evento.

Criar a subscrição do evento

Uma assinatura de evento, alimentada pela Grade de Eventos do Azure, gera eventos com base em alterações no contêiner de blob inscrito. Esse evento é então enviado para o ponto de extremidade de extensão de blob para sua função. Depois de criar uma assinatura de evento, não é possível atualizar a URL do ponto de extremidade.

No Visual Studio Code, escolha o ícone do Azure na barra de atividades. Em Recursos, expanda sua assinatura, expanda Contas de armazenamento, clique com o botão direito do mouse na conta de armazenamento criada anteriormente e selecione Abrir no portal.
Entre no portal do Azure e anote o grupo Recursos da sua conta de armazenamento. Cria os teus outros recursos no mesmo grupo para facilitar a limpeza dos recursos quando terminares.
Selecione a opção Eventos no menu à esquerda.

Na janela Eventos, selecione o botão + Assinatura de Evento e forneça valores da tabela a seguir na guia Básico:

Definição	Valor sugerido	Description
Nome	myBlobEventSub	Nome que identifica a assinatura do evento. Use o nome para encontrar rapidamente a subscrição do evento.
Esquema de Eventos	Esquema de grade de eventos	Use o esquema padrão para eventos.
Nome do tópico do sistema	samples-workitems-blobs	Nome para o tópico, que representa o contêiner. O tópico é criado com a primeira subscrição, e é utilizado para futuras subscrições de eventos.
Filtrar para tipos de evento	Blob criado
Tipo de ponto final	Gancho da Web	O gatilho de armazenamento de blob usa um ponto de extremidade de gancho da Web.
Ponto final	Seu ponto de extremidade de URL baseado no Azure	Use o ponto de extremidade de URL que você criou, que inclui o valor da chave.

Selecione Confirmar seleção para validar o URL do ponto de extremidade.

Selecione a guia Filtros e forneça as seguintes informações aos prompts:

Definição	Valor sugerido	Description
Ativar filtragem de assunto	Ativado	Permite a filtragem em quais blobs podem acionar a função.
O assunto começa com	`/blobServices/default/containers/<CONTAINER_NAME>/blobs/<BLOB_PREFIX>`	Substitua `<CONTAINER_NAME` e `<BLOB_PREFIX>` pelos valores que escolher. Esta configuração ativa a subscrição apenas para blobs que começam com `BLOB_PREFIX` e estão dentro do `CONTAINER_NAME` contentor.
O assunto termina com	.txt	Garante que a função só é ativada por blobs que terminam em `.txt`.

Para obter mais informações sobre como filtrar blobs específicos, consulte Filtragem de eventos para Hubs de Eventos do Azure.

Selecione Criar para criar a assinatura do evento.

Carregar um ficheiro para o contentor

Pode carregar um ficheiro do seu computador para o seu contentor de armazenamento de blobs usando o Visual Studio Code.

No Visual Studio Code, pressione F1 para abrir a paleta de comandos e digite Azure Storage: Upload Files....
Na caixa de diálogo Abrir, escolha um arquivo, de preferência um arquivo de texto, e selecione Carregar .

Forneça as seguintes informações nos pedidos:

Definição	Valor sugerido	Description
Insira o diretório de destino deste upload	predefinição	Aceitar o valor padrão de `/`, que é a raiz do contentor.
Selecione um recurso	Nome da conta de armazenamento	Escolha o nome da conta de armazenamento que você criou em uma etapa anterior.
Selecione um tipo de recurso	Contentores de Blob	Você está carregando para um contêiner de blob.
Selecionar contêiner de Blob	exemplos-itens de trabalho	Esse valor é o nome do contêiner criado em uma etapa anterior.

Navegue pelo sistema de ficheiros local para encontrar um ficheiro para carregar e depois selecione o botão Carregar para carregar o ficheiro.

Verificar a função no Azure

Quando carregas um ficheiro para o contentor samples-workitems , a função é ativada. Pode verificar a função verificando os seguintes itens no portal Azure:

Na sua conta de armazenamento, aceda à página Eventos , selecione Subscrições de Eventos e deverá ver que um evento foi entregue. Pode haver até cinco minutos de atraso para o evento aparecer no gráfico.
De volta à página do aplicativo de funções no portal, em Funções , localize sua função e selecione Invocações e muito mais. Você deve ver os traços escritos a partir da execução bem-sucedida da função.

Clean up resources (Limpar recursos)

Quando você continuar para a próxima etapa e adicionar uma associação de fila de Armazenamento do Azure à sua função, precisará manter todos os seus recursos no lugar para aproveitar o que já fez.

Caso contrário, você pode usar as etapas a seguir para excluir o aplicativo de função e seus recursos relacionados para evitar incorrer em custos adicionais.

No Visual Studio Code, pressione F1 para abrir a paleta de comandos. Na paleta de comandos, procure e selecione Azure: Open in portal.
Escolha seu aplicativo de função e pressione Enter. A página do aplicativo de função é aberta no portal do Azure.
Na guia Visão geral, selecione o link nomeado ao lado de Grupo de recursos.
Na página Grupo de recursos, revise a lista de recursos incluídos e verifique se eles são aqueles que você deseja excluir.
Selecione Eliminar grupo de recursos e siga as instruções.

A eliminação pode demorar alguns minutos. Quando terminar, é apresentada uma notificação durante alguns segundos. Também pode selecionar o ícone de sino na parte superior da página para ver a notificação.

Para obter mais informações sobre os custos das funções, consulte Estimando os custos do plano de consumo.

Próximos passos

Comentários

Esta página foi útil?

Last updated on 2025-11-19