Share via

Tutorial: disparar o Azure Functions em contêineres de blob usando uma assinatura de evento

  • Artigo

Se você estiver usando versões anteriores do gatilho do Armazenamento de Blobs com o Azure Functions, geralmente receberá execuções atrasadas porque o gatilho sonda o contêiner de blobs para atualizações. Você pode reduzir a latência disparando sua função usando uma assinatura de evento para o mesmo contêiner. A assinatura do evento usa a infraestrutura da Grade de Eventos para encaminhar as alterações no contêiner conforme elas ocorrem. Você pode implementar essa funcionalidade usando as extensões mais recentes do Azure Functions.

Este artigo mostra como criar uma função que é executada com base nos eventos disparados quando um blob for adicionado a um contêiner. Você usará o Visual Studio Code para desenvolvimento local e verificar se a função funciona localmente antes de implantar seu projeto no Azure.

  • Criar uma conta de armazenamento geral v2 no Armazenamento do Azure.
  • Criar um contêiner no Armazenamento de Blobs.
  • Criar uma função disparada pelo Armazenamento de Blobs controlado por eventos.
  • Criar uma assinatura de evento para um contêiner de blob.
  • Depurar localmente usando ngrok carregando arquivos.
  • Implantar no Azure e criar uma assinatura de evento filtrada.

Importante

Este artigo usa guias para dar suporte a várias versões do modelo de programação Node.js. O modelo v4 normalmente está disponível e foi projetado para oferecer uma experiência mais flexível e intuitiva para desenvolvedores de JavaScript e TypeScript. Para obter mais detalhes sobre como funciona o modelo v4, consulte o Guia do desenvolvedor do Node.js para o Azure Functions. Para saber mais sobre as diferenças entre os modelos v3 e a v4, consulte o Guia de migração.

Pré-requisitos

Observação

No momento a extensão do Armazenamento do Azure para Visual Studio Code está em versão prévia.

Criar uma conta de armazenamento

Para usar uma assinatura de evento com o Armazenamento do Azure, você precisará de uma conta de armazenamento v2 de uso geral. Por padrão, será possível criar essa conta de armazenamento pelo projeto do Visual Studio Code quando você tiver a extensão do Armazenamento do Azure instalada.

  1. No Visual Studio Code, abra a paleta de comandos (pressione F1) e insira Azure Storage: Create Storage Account.... Nos prompts, forneça as informações a seguir:

    Prompt Ação
    Insira o nome da nova conta de armazenamento Forneça um nome globalmente exclusivo. Os nomes da conta de armazenamento devem ter de 3 a 24 caracteres com apenas letras minúsculas e números. Para facilitar a identificação, usaremos o mesmo nome para o grupo de recursos e o nome do aplicativo de funções.
    Selecione uma localização para novos recursos Para obter um melhor desempenho, escolha uma região perto de você.

    A extensão cria uma conta de armazenamento v2 de uso geral com o nome fornecido. O mesmo nome também será usado para o grupo de recursos que contém a conta de armazenamento.

  2. Depois de criar a conta de armazenamento, abra a paleta de comandos (pressione F1) e insira Azure Storage: Create Blob Container.... Nos prompts, forneça as informações a seguir:

    Prompt Ação
    Selecionar um recurso Selecione a conta de armazenamento criada.
    Insira um nome para o novo contêiner de blob Insira samples-workitems, que é o nome do contêiner referenciado no projeto de código.

Agora que você criou o contêiner de blobs, poderá criar a função que é disparada nesse contêiner e a assinatura de evento que fornece eventos à função.

Criar uma função disparada por blob

Ao criar uma função de gatilho do Armazenamento de Blobs usando o Visual Studio Code, você também cria um novo projeto. Será necessário editar a função para consumir uma assinatura de evento como a origem em vez de usar o contêiner sondado regular.

  1. No Visual Studio Code, abra o aplicativo de funções.

  2. Abra a paleta de comandos (pressione F1), insira Azure Functions: Create Function... e selecione Criar novo projeto.

  3. Para o workspace do projeto, selecione o local do diretório. Lembre-se de criar uma nova pasta ou escolher uma pasta vazia para o workspace do projeto.

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

  4. Nos prompts, forneça as informações a seguir:

    Prompt Ação
    Selecionar um idioma Selecione C#.
    Selecionar um runtime do .NET Selecione .NET 6.0 Isolated LTS para executar em um processo de trabalho isolado ou .NET 6.0 LTS para executar em processo.
    Selecione um modelo para a primeira função do projeto Selecione Azure Blob Storage trigger.
    Forneça um nome de função Digite BlobTriggerEventGrid.
    Forneça um namespace Digite My.Functions.
    Selecione a configuração a partir de "local.settings.json" Selecione Create new local app setting.
    Selecione uma conta de armazenamento Na lista, selecione a conta de armazenamento que você criou.
    Esse é o caminho em sua conta de armazenamento que o gatilho vai monitorar Aceite o valor padrão samples-workitems.
    Selecione como deseja abrir o projeto Selecione Open in current window.
    Prompt Ação
    Selecionar um idioma Selecione Python.
    Selecione o interpretador do Python para criar um ambiente virtual Selecione seu interpretador do Python preferido. Se nenhuma opção for mostrada, digite o caminho completo no binário do Python.
    Selecione um modelo para a primeira função do projeto Selecione Azure Blob Storage trigger.
    Forneça um nome de função Digite BlobTriggerEventGrid.
    Selecione a configuração a partir de "local.settings.json" Selecione Create new local app setting.
    Selecione uma conta de armazenamento Na lista, selecione a conta de armazenamento que você criou.
    Esse é o caminho em sua conta de armazenamento que o gatilho vai monitorar Aceite o valor padrão samples-workitems.
    Selecione como deseja abrir o projeto Selecione Open in current window.
    Prompt Ação
    Selecionar um idioma Selecione Java.
    Selecione uma versão do Java Selecione Java 11 ou Java 8, a versão do Java na qual suas funções são executadas no Azure e que você verificou localmente.
    Forneça uma ID de grupo Selecione com.function.
    Forneça uma ID de artefato Selecione BlobTriggerEventGrid.
    Forneça uma versão Selecione 1.0-SNAPSHOT.
    Forneça um nome de pacote Selecione com.function.
    Forneça um nome de aplicativo Aceite o nome gerado começando com BlobTriggerEventGrid.
    Selecione a ferramenta de build para o projeto Java Selecione Maven.
    Selecione como deseja abrir o projeto Selecione Open in current window.
    Prompt Ação
    Selecione uma linguagem para o 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 projeto Selecione Azure Blob Storage trigger.
    Forneça um nome de função Digite BlobTriggerEventGrid.
    Selecione a configuração a partir de "local.settings.json" Selecione Create new local app setting.
    Selecione uma conta de armazenamento Selecione a conta de armazenamento criada.
    Esse é o caminho em sua conta de armazenamento que o gatilho vai monitorar Aceite o valor padrão samples-workitems.
    Selecione como deseja abrir o projeto Selecione Open in current window.
    Prompt Ação
    Selecione uma linguagem para o projeto de função Selecione JavaScript.
    Selecionar um modelo de programação JavaScript Selecione Model V4.
    Selecione um modelo para a primeira função do projeto Selecione Azure Blob Storage trigger.
    Forneça um nome de função Digite BlobTriggerEventGrid.
    Selecione a configuração a partir de "local.settings.json" Selecione Create new local app setting.
    Selecione uma conta de armazenamento Selecione a conta de armazenamento criada.
    Esse é o caminho em sua conta de armazenamento que o gatilho vai monitorar Aceite o valor padrão samples-workitems.
    Selecione como deseja abrir o projeto Selecione Open in current window.
    Prompt Ação
    Selecione uma linguagem para o projeto de função Selecione PowerShell.
    Selecione um modelo para a primeira função do projeto Selecione Azure Blob Storage trigger.
    Forneça um nome de função Digite BlobTriggerEventGrid.
    Selecione a configuração a partir de "local.settings.json" Selecione Create new local app setting.
    Selecione uma conta de armazenamento Selecione a conta de armazenamento criada.
    Esse é o caminho em sua conta de armazenamento que o gatilho vai monitorar Aceite o valor padrão samples-workitems.
    Selecione como deseja abrir o projeto Selecione Open in current window.

  5. Depois que o prompt for exibido, escolha Selecionar conta de armazenamento>Adicionar ao workspace.

Para simplificar as coisas, este tutorial reutiliza a mesma conta de armazenamento com o aplicativo de funções. No entanto, na produção, talvez você queira usar uma conta de armazenamento separada para o aplicativo de funções. Para obter mais informações, confira Considerações de armazenamento do Azure Functions.

Atualizar a extensão do Armazenamento

Para usar o gatilho do Armazenamento de Blobs baseado na Grade de Eventos, a função exige ao menos a versão 5.x para a extensão do Armazenamento.

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

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs --version 6.1.0

  1. Abra o arquivo de projeto host.json e inspecione o elemento extensionBundle.

  2. Se a extensionBundle.version não for no mínimo 3.3.0 , substitua a extensionBundle pela mais recente:

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

Atualizar a função para usar eventos

No arquivo BlobTriggerEventGrid.cs, adicione Source = BlobTriggerSource.EventGrid aos parâmetros para o atributo de gatilho de Blob, por exemplo:

[Function("BlobTriggerCSharp")]
public async Task Run([BlobTrigger("samples-workitems/{name}", Source = BlobTriggerSource.EventGrid, Connection = "<NAMED_STORAGE_CONNECTION>")] Stream myBlob, string name, FunctionContext executionContext)
{
    var logger = executionContext.GetLogger("BlobTriggerCSharp");
    logger.LogInformation($"C# Blob trigger function Processed blob\n Name: {name} \n Size: {myBlob.Length} Bytes");
}

Depois de criar a função, no arquivo de configuração function.json, adicione "source": "EventGrid" à associação myBlob, por exemplo:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "myblob",
      "type": "blobTrigger",
      "direction": "in",
      "path": "samples-workitems/{name}",
      "source": "EventGrid",
      "connection": "<NAMED_STORAGE_CONNECTION>"
    }
  ]
}

  1. No arquivo Function.java gerado, substitua o conteúdo pelo seguinte código e renomeie o arquivo como BlobTriggerEventGrid.java:

    package com.function;

import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;

/**
* Azure Functions with Azure Blob trigger.
*/
public class BlobTriggerEventGrid {
    /**
    * This function will be invoked when a new or updated blob is detected at the specified path. The blob contents are provided as input to this function.
    */
    @FunctionName("BlobTriggerEventGrid")
    @StorageAccount("glengatesteventgridblob_STORAGE")
    public void run(
        @BlobTrigger(name = "content", path = "samples-workitems/{name}", dataType = "binary", source = "EventGrid" ) 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");
      }
}

  2. Remova o arquivo de teste de unidade associado, que não se aplica mais ao novo tipo de gatilho.

Depois de criar a função, adicione source: "EventGrid" ao objeto options no arquivo TypeScript, por exemplo:

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

Depois de criar a função, adicione source: "EventGrid" ao objeto options no arquivo TypeScript, por exemplo:

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

Depois de criar a função, no arquivo de configuração function.json, adicione "source": "EventGrid" à associação myBlob, por exemplo:

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

Iniciar a depuração local

A Grade de Eventos valida a URL do ponto de extremidade quando você cria uma assinatura de evento no portal do Azure. Essa validação significa que, antes de criar uma assinatura de evento para depuração local, a função precisa estar sendo executada localmente com acesso remoto habilitado pelo utilitário ngrok. Se o código de função local não estiver em execução e acessível para o Azure, você não poderá criar a assinatura de evento.

Determinar o ponto de extremidade do gatilho de blob

Quando a função é executada localmente, o ponto de extremidade padrão usado para um gatilho de armazenamento de blobs controlado por eventos se parece com a seguinte URL:

http://localhost:7071/runtime/webhooks/blobs?functionName=Host.Functions.BlobTriggerEventGrid

http://localhost:7071/runtime/webhooks/blobs?functionName=Host.Functions.BlobTriggerEventGrid

Salve esse caminho, que você usará posteriormente para criar URLs de ponto de extremidade para assinaturas de evento. Se você usou um nome diferente para a função disparada do Armazenamento de Blobs, precisará alterar o valor de functionName na cadeia de caracteres de consulta.

Observação

Como o ponto de extremidade está manipulando eventos de um gatilho de Armazenamento de Blobs, o caminho do ponto de extremidade inclui blobs. A URL do ponto de extremidade de um gatilho da Grade de Eventos teria eventgrid no caminho.

Executar o ngrok

Para interromper uma função que está sendo depurada no computador, você precisa permitir que a Grade de Eventos do Azure se comunique com as funções em execução no computador local.

O utilitário ngrok encaminha solicitações externas para um endereço de servidor proxy gerado aleatoriamente a um endereço e uma porta específicos no computador local, a fim de chamar o ponto de extremidade de webhook da função em execução no computador.

  1. Inicie ngrok usando o seguinte comando:

    ngrok.exe http http://localhost:7071

    Quando o utilitário é iniciado, a janela Comando deve ser semelhante à seguinte captura de tela:

    Screenshot that shows the Command Prompt after starting the

  2. Cópia de HTTPS URL gerada quando ngrok é executado. Esse valor é usado para determinar o ponto de extremidade do webhook no computador exposto usando o ngrok.

Importante

Neste ponto, não pare o ngrok. Sempre que você iniciar o ngrok, a URL HTTPS será regenerada com um valor diferente. Como o ponto de extremidade de uma assinatura de evento não pode ser modificado, você precisa criar uma assinatura de evento sempre que executa ngrok.

A menos que você crie uma conta do ngrok, o tempo máximo de sessão do ngrok é limitado a duas horas.

Criar a URL do ponto de extremidade

O ponto de extremidade usado na assinatura de evento é composto por três partes diferentes, um nome de servidor prefixado, um caminho e uma cadeia de caracteres de consulta. A seguinte tabela descreve essas partes:

Parte da URL Descrição
Prefixo e nome do servidor Quando a função é executada localmente, o nome do servidor com um prefixo https:// vem da URL de Encaminhamento gerada pelo ngrok. Na URL do localhost, a URL do ngrok substitui http://localhost:7071. Ao executar no Azure, você usará o servidor de aplicativo de funções publicado, que geralmente está no formato https://<FUNCTION_APP_NAME>.azurewebsites.net.
Caminho A parte do caminho da URL do ponto de extremidade vem da URL do localhost copiada anteriormente e é semelhante a /runtime/webhooks/blobs de um gatilho de Armazenamento de Blobs. O caminho para um gatilho da Grade de Eventos seria /runtime/webhooks/EventGrid
Cadeia de consulta Para todas as linguagens, incluindo o .NET Isolado, o parâmetro functionName=Host.Functions.BlobTriggerEventGride exceto para o .NET Em processo, que deve ser functionName=BlobTriggerEventGrid na cadeia de caracteres de consulta, define o nome da função que lida com o evento. Se você usou um nome diferente para a função, precisará alterar esse valor. A chave de acesso não é necessária na execução local. Ao executar no Azure, você também precisará incluir um parâmetro code= na URL, que contém uma chave que você pode obter no portal.

A seguinte captura de tela mostra um exemplo de como a URL do ponto de extremidade deve ser ao usar um gatilho do Armazenamento de Blobs, chamado de BlobTriggerEventGrid:

Endpoint selection

Iniciar a depuração

Com o ngrok já em execução, inicie o projeto local da seguinte maneira:

  1. Defina um ponto de interrupção na sua função na linha que administra o registro em log.

  2. Inicie uma sessão de depuração.

    Abra um novo terminal e execute o comando mvn abaixo para iniciar a sessão de depuração.

    mvn azure-functions:run -DenableDebug

    Pressione F5 para iniciar uma sessão de depuração.

Com o código em execução e o ngrok encaminhando solicitações, é hora de criar uma assinatura de evento para o contêiner de blob.

Criar a assinatura de evento

Uma assinatura de evento, na plataforma Grade de Eventos do Azure, gera eventos com base em alterações no contêiner de blob associado. Depois, esse evento é enviado ao ponto de extremidade do webhook no gatilho da função. Depois que uma assinatura de evento é criada, a URL do ponto de extremidade não pode ser alterada. Isso significa que, depois de terminar a depuração local (ou ao reiniciar o ngrok), você precisará excluir e recriar a assinatura de evento.

  1. No Visual Studio Code, escolha o ícone do Azure na barra de atividade. Em Recursos, expanda a assinatura, expanda Contas de armazenamento, clique com o botão direito do mouse na conta de armazenamento que você criou e selecione Abrir no portal.

  2. Entre no portal do Azure e anote o Grupo de recursos da conta de armazenamento. Você criará os outros recursos no mesmo grupo para facilitar a limpeza dos recursos quando terminar.

  3. Selecione a opção Eventos no menu à esquerda.

    Add storage account event

  4. Na janela Eventos, selecione o botão + Assinatura de Evento e forneça valores da seguinte tabela na guia Informações básicas:

    Configuração Valor sugerido Description
    Nome myBlobLocalNgrokEventSub Nome que identifica a assinatura de evento. Você pode usar o nome para localizar rapidamente a assinatura de evento.
    Esquema do evento Esquema da Grade de Eventos Use o esquema padrão para eventos.
    Nome do Tópico do Sistema samples-workitems-blobs Nome do tópico, que representa o contêiner. O tópico é criado com a primeira assinatura e você o usará para futuras assinaturas de eventos.
    Filtro para Tipos de Evento Blob Criado
    Tipo de Ponto de Extremidade Web hook O gatilho de armazenamento de blobs usa um ponto de extremidade de Web hook. Você usaria o Azure Functions para um gatilho da Grade de Eventos.
    Ponto de extremidade Seu ponto de extremidade de URL baseado no ngrok Use o ponto de extremidade de URL baseado no ngrok que você determinou anteriormente.

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

  6. Selecione Criar para criar a assinatura de evento.

Carregar um arquivo no contêiner

Com a assinatura de evento em vigor e o projeto de código e o ngrok ainda em execução, agora você pode carregar um arquivo no contêiner de armazenamento para disparar a função. Você pode carregar um arquivo do computador no contêiner de armazenamento de blobs usando o Visual Studio Code.

  1. No Visual Studio Code, abra a paleta de comandos (pressione F1) e digite Azure Storage: Upload Files....

  2. Na caixa de diálogo Abrir, escolha um arquivo, preferencialmente um arquivo de imagem binária que não seja muito grande. Selecione Carregar.

  3. Forneça as seguintes informações nos prompts:

    Configuração Valor sugerido Descrição
    Selecionar um recurso Nome da conta de armazenamento Escolha o nome da conta de armazenamento que você criou em uma etapa anterior.
    Selecionar um tipo de recurso Contêineres de blob Você está carregando em um contêiner de blob.
    Selecionar contêiner de blob samples-workitems Esse valor é o nome do contêiner que você criou em uma etapa anterior.
    Insira o diretório de destino deste upload padrão Basta aceitar o valor padrão de /, que é a raiz do contêiner.

Esse comando carrega um arquivo do computador no contêiner de armazenamento no Azure. Neste ponto, a instância do ngrok em execução deve relatar que uma solicitação foi encaminhada. Você também verá na saída de func.exe da sessão de depuração que a função foi iniciada. Neste momento, a sessão de depuração deve estar aguardando no ponto de interrupção que você definiu.

Publicar o projeto no Azure

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

Crie o aplicativo de funções

As etapas a seguir criam os recursos necessários no Azure e implantam os arquivos de projeto.

  1. Na paleta de comandos, insira Azure Functions: Criar aplicativo de funções no Azure… (Avançado).

  2. Após os prompts, forneça estas informações:

    Prompt Seleção
    Insira um nome exclusivo globalmente para o novo aplicativo de funções. Digite um nome globalmente exclusivo que identifique o novo aplicativo de funções e selecione ENTER. Caracteres válidos para um nome de aplicativo de funções são a-z, 0-9 e -. Anote esse nome. Você precisará dele mais tarde ao criar a URL do ponto de extremidade.
    Selecione uma pilha de runtime. Escolha a versão da linguagem em que você está fazendo a execução localmente.
    Selecione um SO. Escolha Linux ou Windows. Os aplicativos Python precisam ser executados no Linux.
    Selecione um grupo de recursos para novos recursos. Escolha o nome do grupo de recursos que você criou com sua conta de armazenamento e anotou no portal.
    Selecione uma localização para novos recursos. Selecione um local em uma região perto de você ou perto de outros serviços acessados pelas suas funções.
    Selecione um plano de hospedagem. Escolha Consumo em Hospedagem do plano de consumo sem servidor, em que você só é cobrado quando as funções são executadas.
    Selecione uma conta de armazenamento. Escolha o nome da conta de armazenamento existente que você está usando.
    Selecione um recurso do Application Insights para o seu aplicativo. Escolha Criar recurso do Application Insights e, no prompt, digite um nome para a instância usada para armazenar dados de runtime das suas funções.

    Uma notificação é exibida depois que seu aplicativo de funções é criado e o pacote de implantação é aplicado. Escolha Exibir Saída nessa notificação para exibir a criação e os resultados da implantação, incluindo os recursos do Azure que você criou.

Implantar o código de função

Importante

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

  1. Na área Recursos da atividade do Azure, localize o recurso do aplicativo de funções que você acabou de criar, clique com o botão direito do mouse no recurso e selecione Implantar no aplicativo de funções....

  2. Quando solicitado sobre a substituição de implantações anteriores, selecione Implantar para implantar seu código de função no novo recurso do aplicativo de funções.

  3. Após a conclusão da implantação, escolha Exibir Saída para ver a criação e os resultados 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.

    Screenshot of the View Output window.

Publicar configuração de aplicativo

Como as configurações locais de local.settings.json não são publicadas automaticamente, você precisa carregá-las agora para que a função seja executada corretamente no Azure.

Na paleta de comandos, insira Azure Functions: Carregar Configurações Locais... e, no prompt Selecione um recurso. escolha o nome do aplicativo de funções.

Recriar a assinatura de evento

Agora que o aplicativo de funções está em execução no Azure, você precisa criar uma assinatura de evento. Essa nova assinatura de evento usa o ponto de extremidade da função no Azure. Você também adicionará um filtro à assinatura de evento para que a função só seja disparada quando arquivos JPEG (.jpg) forem adicionados ao contêiner. No Azure, a URL do ponto de extremidade também contém uma chave de acesso, que ajuda a impedir que atores que não sejam a Grade de Eventos acessem o ponto de extremidade.

Obter a chave de extensão do blob

  1. No Visual Studio Code, escolha o ícone do Azure na barra de atividade. Em Recursos, expanda a assinatura, expanda o Aplicativo de Funções, clique com o botão direito do mouse no aplicativo de funções criado e selecione Abrir no portal.

  2. Em Funções no menu à esquerda, selecione Chaves de aplicativo.

  3. Em Chaves do sistema, selecione a chave chamada blobs_extension e copie o valor da chave.

Você incluirá esse valor na cadeia de caracteres de consulta da nova URL do ponto de extremidade.

Criar a URL do ponto de extremidade

Crie uma URL de ponto de extremidade para o gatilho do Armazenamento de Blobs com base no seguinte exemplo:

https://<FUNCTION_APP_NAME>.azurewebsites.net/runtime/webhooks/blobs?functionName=Host.Functions.BlobTriggerEventGrid&code=<BLOB_EXTENSION_KEY>

https://<FUNCTION_APP_NAME>.azurewebsites.net/runtime/webhooks/blobs?functionName=Host.Functions.BlobTriggerEventGrid&code=<BLOB_EXTENSION_KEY>

Neste exemplo, substitua <FUNCTION_APP_NAME> pelo nome do aplicativo de funções e <BLOB_EXTENSION_KEY> pelo valor que você obteve no portal. Se você usou um nome diferente para a função, altere também a cadeia de caracteres de consulta functionName conforme o necessário.

Criar uma assinatura de evento filtrada

Como a URL do ponto de extremidade de uma assinatura de evento não pode ser alterada, você precisa criar uma assinatura de evento. Agora, você também deve excluir a assinatura de evento antiga, pois ela não pode ser reutilizada.

Desta vez, você incluirá o filtro na assinatura de evento para que apenas arquivos JPEG (*.jpg) disparem a função.

  1. No Visual Studio Code, escolha o ícone do Azure na barra de atividade. Em Recursos, expanda a assinatura, expanda Contas de armazenamento, clique com o botão direito do mouse na conta de armazenamento que você criou e selecione Abrir no portal.

  2. No portal do Azure, selecione a opção Eventos no menu à esquerda.

  3. Na janela Eventos, selecione a assinatura de evento antiga baseada no ngrok. Escolha Excluir>Salvar. Essa ação remove a assinatura de evento antiga.

  4. Selecione o botão + Assinatura de Evento e forneça os valores da seguinte tabela na guia Informações básicas:

    Configuração Valor sugerido Description
    Nome myBlobAzureEventSub Nome que identifica a assinatura de evento. Você pode usar o nome para localizar rapidamente a assinatura de evento.
    Esquema do evento Esquema da Grade de Eventos Use o esquema padrão para eventos.
    Filtro para Tipos de Evento Blob Criado
    Tipo de Ponto de Extremidade Web hook O gatilho de armazenamento de blobs usa um ponto de extremidade de Web hook. Você usaria o Azure Functions para um gatilho da Grade de Eventos.
    Ponto de extremidade Seu novo ponto de extremidade de URL baseado no Azure Use o ponto de extremidade de URL que você criou, que inclui o valor da chave.

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

  6. Selecione a guia Filtros, em Filtros de assunto, marque Habilitar filtragem de assunto e digite .jpg em O assunto termina com. Isso filtra eventos apenas para arquivos JPEG.

    Add filter

  7. Selecione Criar para criar a assinatura de evento.

Verificar a função no Azure

Com toda a topologia agora executando o Azure, é hora de verificar se tudo está funcionando corretamente. Como você já está no portal, é mais fácil carregar um arquivo por meio dele.

  1. Na página da conta de armazenamento no portal, selecione Contêineres e escolha o contêiner exemplos-workitems.

  2. Selecione o botão Carregar para abrir a página de carregamento à direita, navegue no sistema de arquivos local para encontrar um arquivo .jpg a ser carregado e depois clique no botão Carregar para carregar o blob. Agora, você pode verificar se a função foi executada com base no evento de upload do contêiner.

  3. Em sua conta de armazenamento, retorne à página Eventos, selecione Assinaturas de Eventos e veja que um evento foi entregue.

  4. De volta à página do aplicativo de funções no portal, em Funções selecione Funções, escolha a função e veja a Contagem Total de Execuções igual a uma.

  5. Em Desenvolvedor, selecione Monitorar e veja os rastreamentos gravados nas execuções de função bem-sucedidas. Pode haver um atraso de cinco minutos, pois os eventos são processados pelo Application Insights.

Limpar recursos

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

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

  1. No Visual Studio Code, pressione F1 para abrir a paleta de comandos. Na paleta de comandos, pesquise e selecione Azure: Open in portal.

  2. Escolha seu aplicativo de funções e pressione ENTER. A página do aplicativo de funções é aberta no portal do Azure.

  3. Na guia Visão geral, selecione o link nomeado ao lado de Grupo de recursos.

    Screenshot of select the resource group to delete from the function app page.

  4. Na página Grupo de recursos, revise a lista de recursos incluídos e verifique se eles são aqueles que você deseja excluir.

  5. Selecione Excluir grupo de recursos e siga as instruções.

    A exclusão poderá levar alguns minutos. Ao ser concluída, uma notificação será exibida por alguns segundos. Também é possível selecionar o ícone de sino na parte superior da página para exibir a notificação.

Para obter mais informações sobre os custos do Functions, confira Como estimar os custos do plano de consumo.

Próximas etapas