Executar uma Função Azure em resposta a um evento de reidratação de bolhas

Para ler uma bolha que se encontra no nível Archive, tem primeiro de reidratar a bolha para o nível Quente ou Fresco. O processo de reidratação pode demorar várias horas a ser concluído. Em vez de sondar repetidamente o estado da operação de reidratação, pode configurar Azure Event Grid para disparar um evento quando a operação de reidratação blob estiver completa e lidar com este evento na sua aplicação.

Quando ocorre um evento, a Grade de Eventos envia o evento para um manipulador de eventos através de um ponto final. Vários serviços da Azure podem servir como manipuladores de eventos, incluindo Funções do Azure. Uma Função Azure é um bloco de código que pode ser executado em resposta a um evento. Este como fazê-lo acompanhar o processo de desenvolvimento de uma Função Azure e, em seguida, configurar a Grade de Eventos para executar a função em resposta a um evento que ocorre quando uma bolha é rehidratada.

Este artigo mostra-lhe como criar e testar uma Função Azure com .NET do Visual Studio. Você pode construir Funções do Azure a partir de uma variedade de ambientes de desenvolvimento local e usando uma variedade de diferentes linguagens de programação. Para obter mais informações sobre línguas apoiadas para Funções do Azure, consulte as línguas apoiadas em Funções do Azure. Para obter mais informações sobre opções de desenvolvimento para Funções do Azure, consulte Código e teste Funções do Azure localmente.

Para obter mais informações sobre as bolhas reidratando do nível Archive, consulte a visão geral da reidratação do blob a partir do nível Archive.

Pré-requisitos

Este artigo mostra-lhe como usar o Visual Studio 2019 ou mais tarde para desenvolver uma Função Azure com .NET. Pode instalar Visual Studio Community gratuitamente. Certifique-se de que configura o Visual Studio para O Desenvolvimento Azure com .NET.

Para depurar a Função Azure localmente, terá de utilizar uma ferramenta que possa enviar um pedido HTTP, como o Carteiro.

É necessária uma subscrição Azure . Se ainda não tem uma conta, crie uma gratuita antes de começar.

Criar uma aplicação de Funções do Azure

Uma aplicação de função é um recurso Azure que serve de recipiente para o seu Funções do Azure. Pode utilizar uma aplicação de função nova ou existente para completar os passos descritos neste artigo.

Para criar uma nova aplicação de função no portal do Azure, siga estes passos:

  1. Na portal do Azure, procure a App de Função. Selecione o ícone 'App' para navegar para a lista de aplicações de função na sua subscrição.

  2. Selecione o botão Criar para criar uma nova aplicação de função.

  3. No separador Basics , especifique um grupo de recursos e forneça um nome único para a nova aplicação de função.

  4. Certifique-se de que a opção Publicar está definida como Código.

  5. A partir do dropdown da pilha runtime , selecione .NET. O campo Versão é automaticamente povoado para utilizar a versão mais recente do núcleo .NET.

  6. Selecione a região para a nova aplicação de funções.

    Screenshot mostrando como criar uma nova aplicação de função no separador Azure - Basics

  7. Depois de ter concluído o separador Básicos , navegue para o separador Hospedagem .

  8. No separador Hospedagem , selecione a conta de armazenamento onde a sua Função Azure será armazenada. Pode escolher uma conta de armazenamento existente ou criar uma nova.

  9. Certifique-se de que o campo do sistema Operativo está definido para o Windows.

  10. No campo do tipo Plano , selecione Consumption (Serverless). Para mais informações sobre este plano, consulte Funções do Azure Plano de Consumo.

    Screenshot mostrando como criar uma nova aplicação de função em Azure - Separador de hospedagem

  11. Selecione Review + Criar para criar a nova aplicação de função.

Para saber mais sobre a configuração da sua aplicação de função, consulte Gerir a sua aplicação de função na documentação Funções do Azure.

Criar uma função Azure como um gatilho de grelha de evento

Em seguida, crie uma Função Azure que será executada quando uma bolha for rehidratada numa determinada conta de armazenamento. Siga estes passos para criar uma Função Azure em Estúdio Visual com C# e .NET Core:

  1. Lançar Visual Studio 2019 e criar um novo projeto Funções do Azure. Para mais detalhes, siga as instruções descritas no Criar um projeto de aplicação de função.

  2. No Conjunto de um novo Funções do Azure passo de aplicação, selecione os seguintes valores:

    • Por predefinição, o tempo de execução Funções do Azure está definido para Funções do Azure v3 (.NET Core). Microsoft recomenda a utilização desta versão do tempo de execução Funções do Azure.
    • Na lista de possíveis gatilhos, selecione Event Grid Trigger. Para obter mais informações sobre o porquê de um gatilho de Grade de Eventos ser o tipo recomendado de gatilho para lidar com um evento de Armazenamento Blob com uma Função Azure, consulte utilizar uma função como manipulador de eventos para eventos de Grelha de Eventos.
    • A definição de Conta de Armazenamento indica onde a sua Função Azure será armazenada. Pode selecionar uma conta de armazenamento existente ou criar uma nova.
  3. Selecione Criar para criar o novo projeto no Visual Studio.

  4. Em seguida, mude o nome da classe e função Azure, conforme descrito no Renome rename a função. Escolha um nome apropriado para o seu cenário.

  5. No Visual Studio, selecione Tools | NuGet Package Manager | Package Manager Consola e, em seguida, instale os seguintes pacotes a partir da consola:

    Install-Package Azure.Storage.Blobs
    Install-Package Microsoft.ApplicationInsights.WorkerService
    Install-Package Microsoft.Azure.WebJobs.Logging.ApplicationInsights
    
  6. No ficheiro de classe para a sua Função Azure, cole nas seguintes declarações:

    using System;
    using System.IO;
    using System.Text;
    using Microsoft.Azure.WebJobs;
    using Microsoft.Azure.EventGrid.Models;
    using Microsoft.Azure.WebJobs.Extensions.EventGrid;
    using Microsoft.Extensions.Logging;
    using Azure;
    using Azure.Storage.Blobs;
    using Azure.Storage.Blobs.Models;
    
  7. Localize o método Executar no ficheiro de classe. Este é o método que corre quando um evento ocorre. Cole o seguinte código no corpo do método Executar . Lembre-se de substituir os valores de espaço reservado nos suportes de ângulo com os seus próprios valores:

    // When either Microsoft.Storage.BlobCreated or Microsoft.Storage.BlobTierChanged
    // event occurs, write the event details to a log blob in the same container
    // as the event subject (the blob for which the event occurred).
    
    // Create a unique name for the log blob.
    string logBlobName = string.Format("function-log-{0}.txt", DateTime.UtcNow.Ticks);
    
    // Populate connection string with your Shared Key credentials.
    const string ConnectionString = "DefaultEndpointsProtocol=https;AccountName=<account-name>;AccountKey=<account-key>;EndpointSuffix=core.windows.net";
    
    // Get data from the event.
    dynamic data = eventGridEvent.Data;
    string eventBlobUrl = Convert.ToString(data.url);
    string eventApi = Convert.ToString(data.api);
    
    // Build string containing log information.
    StringBuilder eventInfo = new StringBuilder();
    eventInfo.AppendLine(string.Format("{0} operation occurred.", eventApi));
    eventInfo.AppendLine(string.Format("Blob URL: {0}", eventBlobUrl));
    eventInfo.AppendLine($@"Additional event details:
        Id=[{eventGridEvent.Id}]
        EventType=[{eventGridEvent.EventType}]
        EventTime=[{eventGridEvent.EventTime}]
        Subject=[{eventGridEvent.Subject}]
        Topic=[{eventGridEvent.Topic}]");
    
    // If event was BlobCreated and API call was CopyBlob, respond to the event.
    bool copyBlobEventOccurred = (eventGridEvent.EventType == "Microsoft.Storage.BlobCreated") &&
                                 (eventApi == "CopyBlob");
    
    // If event was BlobTierChanged and API call was SetBlobTier, respond to the event.
    bool setTierEventOccurred = (eventGridEvent.EventType == "Microsoft.Storage.BlobTierChanged") &&
                                (eventApi == "SetBlobTier");
    
    // If one of these two events occurred, write event info to a log blob.
    if (copyBlobEventOccurred | setTierEventOccurred)
    {
        // Create log blob in same account and container.
        BlobUriBuilder logBlobUriBuilder = new BlobUriBuilder(new Uri(eventBlobUrl))
        {
            BlobName = logBlobName
        };
    
        BlobClient logBlobClient = new BlobClient(ConnectionString,
                                                  logBlobUriBuilder.BlobContainerName,
                                                  logBlobName);
    
        byte[] byteArray = Encoding.ASCII.GetBytes(eventInfo.ToString());
    
        try
        {
            // Write the log info to the blob.
            // Overwrite if the blob already exists.
            using (MemoryStream memoryStream = new MemoryStream(byteArray))
            {
                BlobContentInfo blobContentInfo =
                    logBlobClient.Upload(memoryStream, overwrite: true);
            }
        }
        catch (RequestFailedException e)
        {
            Console.WriteLine(e.Message);
            throw;
        }
    }
    

Para obter mais informações sobre o desenvolvimento de Funções do Azure, consulte Orientação para o desenvolvimento de Funções do Azure.

Para saber mais sobre as informações que estão incluídas quando um evento blob Storage é publicado para um manipulador de eventos, consulte Armazenamento de Blobs do Azure como fonte de Grade de Eventos.

Executar a Função Azure localmente no depurador

Para testar o seu código de função Azure localmente, tem de enviar manualmente um pedido HTTP que desencadeie o evento. Pode publicar o pedido usando uma ferramenta como o Carteiro.

No topo do ficheiro de classe para a sua Função Azure está um ponto final URL que pode usar para testes no ambiente local. Publicar o pedido com este URL desencadeia o evento no ambiente local para que possa depurar o seu código. O URL está no seguinte formato:

http://localhost:7071/runtime/webhooks/EventGrid?functionName={functionname}

O pedido que envia para este ponto final é um pedido simulado. Não envia nem recebe dados da sua conta de Armazenamento Azure.

Siga estes passos para construir e envie um pedido para este ponto final. Este exemplo mostra como enviar o pedido com o Carteiro.

  1. No Postman, crie um novo pedido.

  2. Cole o URL acima indicado no campo para o URL de pedido, substituindo o nome da sua função {functionname} e removendo os aparelhos encaracolados. Certifique-se de que o verbo do pedido está definido para GET.

    Screenshot mostrando como especificar URL local para o gatilho do evento no Carteiro

  3. Adicione o cabeçalho do tipo de conteúdo e coloque-o para aplicação/json.

  4. Adicione o cabeçalho tipo aeg-event e desagrega-o para Notificação.

    Screenshot mostrando configuração do cabeçalho para pedido local para desencadear evento

  5. No Carteiro, especifique o corpo de pedido, com o tipo de corpo definido para JSON e o formato a cru. O exemplo a seguir simula um pedido copy Blob . Substitua os valores do espaço reservado nos suportes de ângulo com os seus próprios valores. Note que não é necessário alterar valores de data/hora ou identificador, pois este é um pedido simulado:

    [{
      "topic": "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account>",
      "subject": "/blobServices/default/containers/<container-name>/blobs/<blob-name>",
      "eventType": "Microsoft.Storage.BlobCreated",
      "id": "2bfb587b-501e-0094-2746-8b2884065d32",
      "data": {
        "api": "CopyBlob",
        "clientRequestId": "3d4dedc7-6c27-4816-9405-fdbfa806b00c",
        "requestId": "2bfb587b-501e-0094-2746-8b2884000000",
        "eTag": "0x8D9595DCA505BDF",
        "contentType": "text/plain",
        "contentLength": 48,
        "blobType": "BlockBlob",
        "url": "https://<storage-account>.blob.core.windows.net/<container-name>/<blob-name>",
        "sequencer": "0000000000000000000000000000201B00000000004092a5",
        "storageDiagnostics": {
          "batchId": "8a92736a-6006-0026-0046-8bd7f5000000"
        }
      },
      "dataVersion": "",
      "metadataVersion": "1",
      "eventTime": "2021-08-07T04:42:41.0730463Z"
    }]
    
  6. No Visual Studio, coloque os pontos de rutura desejados no seu código e pressione F5 para executar o depurador.

  7. No Carteiro, selecione o botão Enviar o pedido para o ponto final.

Quando envia o pedido, a Grade de Eventos chama a sua Função Azure e pode desordá-la normalmente. Para obter informações e exemplos adicionais, consulte manualmente o pedido na documentação Funções do Azure.

O pedido que desencadeia o evento é simulado, mas a Função Azure que funciona quando o evento dispara escreve informação de registo para uma nova bolha na sua conta de armazenamento. Pode verificar o conteúdo da bolha e ver o seu último tempo modificado na portal do Azure, como mostra a seguinte imagem:

Screenshot mostrando o conteúdo da bolha de registo na portal do Azure

Publicar a Função do Azure

Depois de ter testado a sua Função Azure localmente, o próximo passo é publicar a Função Azure para a App de Função Azure que criou anteriormente. A função deve ser publicada para que possa configurar a Grade de Eventos para enviar eventos que ocorram na conta de armazenamento para o ponto final da função.

Siga estes passos para publicar a função:

  1. Em Explorador de Soluções, selecione e mantenha (ou clique à direita) no seu projeto de Funções do Azure e escolha Publicar.

  2. Na janela Publicar , selecione Azure como alvo e, em seguida, escolha Seguinte.

  3. Selecione Azure Function App (Windows) como o alvo específico e, em seguida, escolha Seguinte.

  4. No separador De instância de Funções , selecione a sua subscrição a partir do menu suspenso e, em seguida, localize a sua App de Função Azure na lista de aplicações de função disponíveis.

  5. Certifique-se de que a execução da caixa de verificação de ficheiros de pacote está selecionada.

  6. Selecione Acabamento para preparar para publicar a função.

  7. Na página Publicar , verifique se a configuração está correta. Se vir um aviso de que a dependência do serviço para o Application Insights não está configurada, pode configurá-la a partir desta página.

  8. Selecione o botão Publicar para começar a publicar a Função Azure para a App de Função Azure que criou anteriormente.

    Screenshot mostrando página para publicar Azure Function do Visual Studio

Sempre que escoda alterações ao código na sua Função Azure, tem de publicar a função atualizada para Azure.

Subscreva eventos de reidratação blob a partir de uma conta de armazenamento

Tem agora uma aplicação de função que contém uma Função Azure que pode ser executada em resposta a um evento. O próximo passo é criar uma subscrição de eventos a partir da sua conta de armazenamento. A subscrição do evento configura a conta de armazenamento para publicar um evento através da Grade de Eventos em resposta a uma operação numa bolha na sua conta de armazenamento. Em seguida, a Grade de Eventos envia o evento para o ponto final do manipulador de eventos que especificou. Neste caso, o manipulador de eventos é a Função Azure que criou na secção anterior.

Ao criar a subscrição do evento, pode filtrar quais os eventos enviados para o manipulador de eventos. Os eventos a capturar ao reidratar uma bolha do nível Archive são Microsoft. Storage.BlobTierChanged, correspondente a uma operação set Blob Tier, e Microsoft. Storage.BlobCreated eventos, correspondentes a uma operação Copy Blob. Dependendo do seu cenário, talvez queira lidar apenas com um destes eventos.

Para criar a subscrição do evento, siga estes passos:

  1. No portal do Azure, navegue para a conta de armazenamento que contém bolhas para reidratar a partir do nível Archive.

  2. Selecione a definição de Eventos no painel de navegação esquerdo.

  3. Na página Eventos , selecione Mais opções.

  4. Selecione Criar Subscrição de Eventos.

  5. Na página De Subscrição de Eventos Create , na secção de detalhes de subscrição do Evento , forneça um nome para a subscrição do evento.

  6. Na secção detalhes tópicos , forneça um nome para o tópico do sistema. O tópico do sistema representa um ou mais eventos que são publicados pela Azure Storage. Para obter mais informações sobre tópicos do sistema, consulte os tópicos do Sistema em Azure Event Grid.

  7. Na secção Tipos de Eventos , selecione os eventos Blob Created e Blob Tier Changed . Dependendo da forma como escolhes reidratar uma bolha do nível do Arquivo, um destes dois eventos vai disparar.

    Screenshot mostrando como selecionar tipos de eventos para eventos de reidratação blob no portal do Azure

  8. Na secção de detalhes do Ponto final , selecione Azure Function a partir do menu suspenso.

  9. Escolha Selecionar um ponto final para especificar a função que criou na secção anterior. No diálogo Select Azure Function , escolha a aplicação de subscrição, grupo de recursos e função para a sua Função Azure. Por fim, selecione o nome da função a partir do dropdown e escolha Confirmar a seleção.

    Screenshot mostrando como selecionar uma Função Azure como ponto final para uma subscrição de Grade de Eventos

  10. Selecione o botão Criar para criar a subscrição do evento e comece a enviar eventos para o manipulador de eventos Azure Function.

Para saber mais sobre subscrições de eventos, consulte Azure Event Grid conceitos.

Teste o manipulador de eventos Azure Function

Para testar a Função Azure, pode desencadear um evento na conta de armazenamento que contenha a subscrição do evento. A subscrição do evento que criou anteriormente está a ser filtrada em dois eventos, Microsoft. Storage.BlobCreated e Microsoft. Storage.BlobTierChanged. Quando qualquer um destes eventos disparar, irá desencadear a sua Função Azure.

A Função Azure mostrada neste artigo escreve a uma bolha de log em dois cenários:

  • Quando o evento estiver Microsoft. Storage.BlobCreated e a operação API é Copy Blob.
  • Quando o evento estiver Microsoft. Storage.BlobTierChanged e a operação API é Definir Blob Tier.

Para aprender a testar a função reidratando uma bolha, consulte um destes dois procedimentos:

Após a reidratação, a bolha de tronco é escrita para o mesmo recipiente que a bolha que você rehidratado. Por exemplo, depois de reidratar uma bolha com uma operação de cópia, pode ver no portal do Azure que a bolha de origem original permanece no nível Archive, a bolha de destino totalmente rehidratada aparece no nível online alvo, e a bolha de log que foi criada pela Função Azure também aparece na lista.

Screenshot mostrando a bolha original no nível Archive, a bolha rehidratada no nível quente, e a bolha de log escrita pelo manipulador de eventos

Tenha em mente que a reidratação de uma bolha pode demorar até 15 horas, dependendo da definição de prioridade de reidratação. Se definir a prioridade de reidratação para Alto, a reidratação pode completar em menos de uma hora para bolhas com menos de 10 GB de tamanho. No entanto, uma reidratação de alta prioridade incorre num custo maior. Para obter mais informações, consulte a visão geral da reidratação do blob a partir do nível Archive.

Dica

Embora o objetivo deste como lidar com estes eventos no contexto da reidratação blob, para fins de teste também pode ser útil observar estes eventos em resposta ao upload de uma bolha ou alterar o nível de uma bolha online (ou seja, de Hot to Cool), porque o evento dispara imediatamente.

Para obter mais informações sobre como filtrar eventos em Event Grid, consulte Como filtrar eventos para Azure Event Grid.

Ver também