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

  • Artigo

Se você estiver usando versões anteriores do gatilho de Armazenamento de Blob com o Azure Functions, geralmente recebe execuções atrasadas porque o gatilho sonda o contêiner de blob em busca de atualizações. Você pode reduzir a latência acionando sua função usando uma assinatura de evento para o mesmo contêiner. A assinatura de evento usa a infraestrutura de Grade de Eventos para encaminhar alterações no contêiner à medida que elas ocorrem. Você pode implementar esse recurso usando as extensões mais recentes do Azure Functions.

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

  • Crie uma conta v2 de armazenamento geral no Armazenamento do Azure.
  • Crie um contêiner no armazenamento de blobs.
  • Crie uma função acionada de Blob Storage orientada a eventos.
  • Crie uma assinatura de evento para um contêiner de blob.
  • Depure localmente usando ngrok carregando arquivos.
  • Implante no Azure e crie uma assinatura de evento filtrada.

Importante

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

Pré-requisitos

  • O utilitário ngrok , que fornece uma maneira para o Azure chamar sua função em execução local.

  • Extensão de Armazenamento do Azure para Visual Studio Code, minimamente versão 5.x.

Nota

A extensão de Armazenamento do Azure para Visual Studio Code está atualmente em visualização.

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, você pode criar essa conta de armazenamento a partir do seu projeto do Visual Studio Code quando tiver a extensão de Armazenamento do Azure instalada.

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

    Prompt 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 facilitar a identificação, usaremos o mesmo nome para o grupo de recursos e o nome do aplicativo de função.
    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 fornecido. O mesmo nome também é 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 digite Azure Storage: Create Blob Container.... Nos prompts, forneça as seguintes informações:

    Prompt Ação
    Selecione um recurso Selecione a conta de armazenamento 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.

Agora que você criou o contêiner de blob, pode criar a função que aciona esse contêiner e a assinatura de evento que entrega eventos para sua função.

Criar uma função acionada por Blob

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

  1. No Visual Studio Code, abra seu aplicativo de função.

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

  3. Para o espaço de trabalho do projeto, selecione o local do 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.

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

    Prompt Ação
    Selecione um idioma Selecione C#.
    Selecione um tempo de execução do .NET Selecione .NET 6.0 Isolated LTS para execução em um processo de trabalho isolado ou .NET 6.0 LTS em processo.
    Selecione um modelo para a primeira função do seu projeto Selecione Azure Blob Storage trigger.
    Fornecer um nome de função Introduzir BlobTriggerEventGrid.
    Fornecer um namespace Introduzir My.Functions.
    Selecione a configuração de "local.settings.json" Selecione Create new local app setting.
    Selecione uma conta de armazenamento Selecione a conta de armazenamento que você criou na lista.
    Este é o caminho dentro da sua conta de armazenamento que o gatilho monitorará Aceite o valor samples-workitemspadrão .
    Selecione como gostaria de abrir o seu projeto Selecione Open in current window.
    Prompt Ação
    Selecione um idioma Selecione Python.
    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 Azure Blob Storage trigger.
    Fornecer um nome de função Introduzir BlobTriggerEventGrid.
    Selecione a configuração de "local.settings.json" Selecione Create new local app setting.
    Selecione uma conta de armazenamento Selecione a conta de armazenamento que você criou na lista.
    Este é o caminho dentro da sua conta de armazenamento que o gatilho monitorará Aceite o valor samples-workitemspadrão .
    Selecione como gostaria de abrir o seu projeto Selecione Open in current window.
    Prompt 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 BlobTriggerEventGrid.
    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 BlobTriggerEventGrid.
    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.
    Prompt 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.
    Fornecer um nome de função Introduzir BlobTriggerEventGrid.
    Selecione a configuração de "local.settings.json" Selecione Create new local app setting.
    Selecione uma conta de armazenamento Selecione a conta de armazenamento que você criou.
    Este é o caminho dentro da sua conta de armazenamento que o gatilho monitorará Aceite o valor samples-workitemspadrão .
    Selecione como gostaria de abrir o seu projeto Selecione Open in current window.
    Prompt 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.
    Fornecer um nome de função Introduzir BlobTriggerEventGrid.
    Selecione a configuração de "local.settings.json" Selecione Create new local app setting.
    Selecione uma conta de armazenamento Selecione a conta de armazenamento que você criou.
    Este é o caminho dentro da sua conta de armazenamento que o gatilho monitorará Aceite o valor samples-workitemspadrão .
    Selecione como gostaria de abrir o seu projeto Selecione Open in current window.
    Prompt 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.
    Fornecer um nome de função Introduzir BlobTriggerEventGrid.
    Selecione a configuração de "local.settings.json" Selecione Create new local app setting.
    Selecione uma conta de armazenamento Selecione a conta de armazenamento que você criou.
    Este é o caminho dentro da sua conta de armazenamento que o gatilho monitorará Aceite o valor samples-workitemspadrão .
    Selecione como gostaria de abrir o seu projeto Selecione Open in current window.

  5. Depois que o prompt for exibido, selecione Selecionar conta>de armazenamento Adicionar ao espaço de trabalho.

Para simplificar, este tutorial reutiliza a mesma conta de armazenamento com 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.

Atualizar a extensão de armazenamento

Para usar o gatilho de Armazenamento de Blob baseado em Grade de Eventos, sua função requer pelo menos a versão 5.x para a extensão de Armazenamento.

Para atualizar seu projeto com a versão de extensão necessária, na janela 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 extensionBundle elemento .

  2. Se extensionBundle.version não for pelo menos 3.3.0 , substitua extensionBundle pelo 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" à myBlob ligação, 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 gerado Function.java , substitua o conteúdo pelo código a seguir e renomeie o arquivo para 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 options objeto 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 options objeto em seu arquivo JavaScript, 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" à myBlob ligação, por exemplo:

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

Iniciar 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, sua função deve ser executada localmente com acesso remoto habilitado pelo utilitário ngrok. Se seu código de função local não estiver em execução e acessível ao Azure, você não poderá criar a assinatura do evento.

Determinar o ponto de extremidade do gatilho de blob

Quando sua função é executada localmente, o ponto de extremidade padrão usado para um gatilho de armazenamento de blob 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á mais tarde para criar URLs de ponto de extremidade para assinaturas de eventos. Se você usou um nome diferente para sua função acionada de Armazenamento de Blob, precisará alterar o functionName valor na cadeia de caracteres de consulta.

Nota

Como o ponto de extremidade está manipulando eventos para um gatilho de Armazenamento de Blob, o caminho do ponto de extremidade inclui blobs. Em vez disso, a URL do ponto de extremidade para um gatilho de Grade de Eventos teria eventgrid no caminho.

Executar ngrok

Para entrar em uma função que está sendo depurada em sua máquina, você deve fornecer uma maneira para a Grade de Eventos do Azure se comunicar com funções em execução em seu computador local.

O utilitário ngrok encaminha solicitações externas para um endereço de servidor proxy gerado aleatoriamente para um endereço e porta específicos em seu computador local. através para chamar o ponto de extremidade webhook da função em execução na sua máquina.

  1. Inicie o ngrok usando o seguinte comando:

    ngrok.exe http http://localhost:7071

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

    Screenshot that shows the Command Prompt after starting the

  2. Copie o URL HTTPS gerado quando o ngrok é executado. Esse valor é usado para determinar o ponto de extremidade do webhook no seu computador exposto usando ngrok.

Importante

Neste ponto, não pare ngrok. Sempre que você inicia ngrok, a URL HTTPS é regenerada com um valor diferente. Como o ponto de extremidade de uma assinatura de evento não pode ser modificado, você precisa criar uma nova assinatura de evento toda vez que executar ngroko .

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

Criar o 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 tabela a seguir descreve essas partes:

Parte URL Description
Prefixo e nome do servidor Quando sua função é executada localmente, o nome do servidor com um https:// prefixo vem da URL de encaminhamento gerada pelo ngrok. No URL localhost, o URL ngrok substitui http://localhost:7071o . Ao executar no Azure, você usará o servidor de aplicativo de função 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 host local copiada anteriormente e se /runtime/webhooks/blobs parece com um gatilho de Armazenamento de Blob. O caminho para um gatilho de Grade de Eventos seria /runtime/webhooks/EventGrid
Cadeias de consulta Para todos os idiomas, incluindo .NET Isolado o functionName=Host.Functions.BlobTriggerEventGrid parâmetro, exceto para .NET In-process que deve estar functionName=BlobTriggerEventGrid na seqüência de caracteres de consulta define o nome da função que manipula o evento. Se você usou um nome diferente para sua função, precisará alterar esse valor. Uma chave de acesso não é necessária quando executada localmente. Ao executar no Azure, você também precisará incluir um code= parâmetro na URL, que contém uma chave que você pode obter do portal.

A captura de tela a seguir mostra um exemplo de como a URL final do ponto de extremidade deve parecer ao usar um gatilho de Armazenamento de Blob chamado BlobTriggerEventGrid:

Endpoint selection

Iniciar depuração

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

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

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

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

    mvn azure-functions:run -DenableDebug

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

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

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 vinculado. Esse evento é então enviado para o ponto de extremidade do webhook no gatilho da sua 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 concluir a depuração local (ou se reiniciar o ngrok), você precisará excluir e recriar a assinatura do evento.

  1. 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.

  2. Entre no portal do Azure e anote o grupo Recursos da sua conta de armazenamento. Você criará seus outros recursos no mesmo grupo para facilitar a limpeza de 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 tabela a seguir na guia Básico:

    Definição Valor sugerido Description
    Nome myBlobLocalNgrokEventSub Nome que identifica a assinatura do evento. Você pode usar o nome para encontrar rapidamente a assinatura 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 assinatura e você o usará para futuras assinaturas 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. Você usaria o Azure Functions para um gatilho de Grade de Eventos.
    Ponto final Seu ponto de extremidade de URL baseado em ngrok Use o ponto de extremidade de URL baseado em ngrok que você determinou anteriormente.

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

  6. Selecione Criar para criar a assinatura do evento.

Carregar um ficheiro para o contentor

Com a assinatura do evento em vigor e seu projeto de código e ngrok ainda em execução, agora você pode carregar um arquivo para seu contêiner de armazenamento para acionar sua função. Você pode carregar um arquivo do seu computador para o contêiner de armazenamento de blob 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, de preferência um arquivo de imagem binário que não seja muito grande, selecione Carregar .

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

    Definição Valor sugerido Description
    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.
    Insira o diretório de destino deste upload default Basta aceitar o valor padrão de , que é a raiz do /contêiner.

Este comando carrega um arquivo do seu computador para o contêiner de armazenamento no Azure. Neste ponto, sua instância ngrok em execução deve informar que uma solicitação foi encaminhada. Você também verá na saída func.exe da sessão de depuração que sua função foi iniciada. Espero que, neste momento, sua sessão de depuração esteja esperando por você onde você define o ponto de interrupção.

Publicar o projeto no Azure

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.

Criar a aplicação de funções

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

  1. No palete de comandos, insira Azure Functions: Create function app in Azure... (Avançado).

  2. Seguindo as instruções, forneça estas informações:

    Prompt Seleção
    Insira um nome globalmente exclusivo para o novo aplicativo de função. 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 -. Anote este nome; você precisará dele mais tarde ao criar a nova URL do ponto de extremidade.
    Selecione uma pilha de tempo de execução. Escolha a versão de idioma na qual você está executando localmente.
    Selecione um sistema operacional. Escolha Linux ou Windows. Os aplicativos Python devem 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, que você anotou anteriormente no portal.
    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 um plano de hospedagem. Escolha Consumo para hospedagem do plano de consumo sem servidor, onde você só será cobrado quando suas funções forem 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 seu aplicativo. Escolha Create new Application Insights resource (Criar novo recurso do Application Insights) e, no prompt, digite um nome para a instância usada para armazenar dados de tempo de execução de suas funções.

    Uma notificação aparece depois que seu aplicativo de função é criado e o pacote de implantação é aplicado. Selecione Exibir Saída nesta notificação para exibir os resultados da criação e da implantaçã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.

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

  2. 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.

  3. Após a conclusão da implantação, 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.

    Screenshot of the View Output window.

Publicar configurações do aplicativo

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

No palete de comandos, insira Azure Functions: Upload Local Settings..., e no prompt Select a resource. , escolha o nome do seu aplicativo de função.

Recriar a subscrição do evento

Agora que o aplicativo de função está sendo executado no Azure, você precisa criar uma nova assinatura de evento. Esta nova subscrição de eventos utiliza o ponto de extremidade da sua função no Azure. Você também adicionará um filtro à assinatura do evento para que a função só seja acionada 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 bloquear o acesso de atores diferentes da Grade de Eventos ao ponto de extremidade.

Obter a chave de extensão de blob

  1. No Visual Studio Code, escolha o ícone do 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.

  2. Em Funções no menu à esquerda, selecione Teclas do 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 o URL do ponto de extremidade

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.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 seu aplicativo de função e substitua <BLOB_EXTENSION_KEY> pelo valor que você obteve do portal. Se você usou um nome diferente para sua função, também precisará alterar a cadeia de caracteres de functionName consulta conforme necessário.

Criar uma subscrição de evento filtrada

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

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

  1. 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.

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

  3. Na janela Eventos, selecione sua assinatura de evento antiga baseada em ngrok, selecione Excluir Salvar>. Esta ação remove a assinatura de evento antiga.

  4. 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 myBlobAzureEventSub Nome que identifica a assinatura do evento. Você pode usar o nome para encontrar rapidamente a assinatura do evento.
    Esquema de Eventos Esquema de grade de eventos Use o esquema padrão para 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. Você usaria o Azure Functions para um gatilho de Grade de Eventos.
    Ponto final 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 o URL do ponto de extremidade.

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

    Add filter

  7. Selecione Criar para criar a assinatura do evento.

Verificar a função no Azure

Com toda a topologia agora executando o Azure, é hora de verificar se tudo está funcionando corretamente. Uma vez que já está no portal, é mais fácil carregar um ficheiro a partir daí.

  1. Na página da sua conta de armazenamento no portal, selecione Contêineres e selecione seu contêiner de itens de trabalho de amostras.

  2. Selecione o botão Carregar para abrir a página de carregamento à direita, navegue no sistema de ficheiros local para encontrar um .jpg ficheiro para carregar e, em seguida, selecione o botão Carregar para carregar o blob. Agora, você pode verificar se sua função foi executada com base no evento de carregamento de contêiner.

  3. Na sua conta de armazenamento, regresse à página Eventos , selecione Subscrições de Eventos e deverá ver que um evento foi entregue.

  4. De volta à página do aplicativo de funções no portal, em Funções , selecione Funções, escolha sua função e você verá uma Contagem Total de Execução de pelo menos uma.

  5. Em Desenvolvedor, selecione Monitor e você verá os rastreamentos escritos a partir de suas execuções de função bem-sucedidas. Pode haver um atraso de até cinco minutos à medida que os eventos são processados pelo Application Insights.

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.

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

  2. Escolha seu aplicativo de função e pressione Enter. A página do aplicativo de função é 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 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