Executar uma Função do Azure em resposta a um evento de re hidratação blob

Para ler um blob na escarla de Arquivo, primeiro tem de re hidratar o blob para a escaleira quente ou fixe. O processo de re hidratação pode demorar várias horas a ser concluído. Em vez de analisar repetidamente o estado da operação de re hidratação, pode configurar a Grelha de Eventos do Azure para atear um evento quando a operação de re hidratação de blob estiver concluída e tratar deste evento na sua aplicação.

Quando ocorre um evento, a Grelha de Eventos envia o evento para um organizador de eventos através de um ponto final. Vários serviços do Azure podem servir como organizadores de eventos, incluindo as Funções do Azure. Uma Função do Azure é um bloco de código que pode ser executado em resposta a um evento. Este procedimento vai dar-lhe uma forma de o ajudar a desenvolver uma Função do Azure e, em seguida, configurar a Grelha de Eventos para executar a função em resposta a um evento que ocorre quando um blob é re hidratado.

Este artigo mostra-lhe como criar e testar uma Função do Azure com o .NET a partir Visual Studio. Pode criar Funções do Azure a partir de vários ambientes de desenvolvimento local e através de várias linguagens de programação diferentes. Para obter mais informações sobre os idiomas suportados para as Funções do Azure, consulte Idiomas suportados nas Funções do Azure. Para obter mais informações sobre as opções de desenvolvimento para Funções do Azure, consulte Código e teste as Funções do Azure localmente.

Para obter mais informações sobre como re hidratar blobs a partir da escarave de Arquivo, consulte o tier do Arquivo para obter informações gerais sobre a rename.

Pré-requisitos

Este artigo mostra-lhe como utilizar o Visual Studio 2019 para desenvolver uma Função do Azure com o .NET. Pode instalar o Visual Studio Community gratuitamente. Certifique-se de que configura o Visual Studio para o Azure Development com .NET.

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

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

Criar uma aplicação Função Azure

Uma aplicação de função é um recurso do Azure que serve como um contentor para as suas Funções do Azure. Pode utilizar uma aplicação de funções nova ou existente para concluir os passos descritos neste artigo.

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

  1. No portal do Azure, procure Aplicação de Funções. Selecione o ícone da Aplicação de Funções 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 Noções Básicas, especifique um grupo de recursos e forneça um nome exclusivo para a nova aplicação de função.

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

  5. No dropdown da pilha Runtime,selecione .NET. O campo Versão é preenchido automaticamente para utilizar a versão mais recente do .NET Core.

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

    Captura de ecrã a mostrar como criar uma nova aplicação de função no Azure – separador Noções Básicas

  7. Depois de concluir o separador Noções Básicas, navegue para o separador Alojo.

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

  9. Certifique-se de que o campo Sistema operativo está definido para Windows.

  10. No campo Tipo de plano, selecione Consumo (Sem Servidor). Para obter mais informações sobre este plano, consulte O alojamento do plano de Consumo de Funções do Azure.

    Captura de ecrã a mostrar como criar uma nova aplicação de função no Azure - separador Anfitrião

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

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

Criar uma Função do Azure como um ativador de Grelha de Eventos

Em seguida, crie uma Função do Azure que será executada quando um blob é re hidratado numa conta de armazenamento específica. Siga estes passos para criar uma Função do Azure no Visual Studio com C# e .NET Core:

  1. Instrua Visual Studio 2019 e crie um novo projeto de Funções do Azure. Para obter detalhes, siga as instruções descritas em Criar um projeto de aplicação de função.

  2. No passo Criar uma nova aplicação funções do Azure, selecione os seguintes valores:

    • Por predefinição, o tempo de runtime das Funções do Azure está definido para Funções do Azure v3 (.NET Core). A Microsoft recomenda que utilize esta versão do Azure Functions runtime.
    • Na lista de possíveis accionadores, selecione Acionador de Grelha de Eventos. Para obter mais informações sobre o motivo pelo qual um ativador da Grelha de Eventos é o tipo de ativador recomendado para lidar com um evento Blob Armazenamento com uma Função do Azure, consulte Utilizar uma função como um organizadorde eventos para eventos da Grelha de Eventos.
    • A Armazenamento conta de Cliente indica onde a sua Função do 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, nome da turma e função Azure, conforme descrito em Dar outro nome à função. Escolha um nome adequado para o seu cenário.

  5. No Visual Studio, selecione ToolsNuGet Gestor de PacotesGestor de Pacotes 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 da sua Função do Azure, colar nas seguintes instruções utilizando instruçõ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 turma. Este é o método que é executado quando um evento ocorre. Colar o seguinte código no corpo do método Executar. Lembre-se de substituir os valores do espaço nos parênteses angulares pelos 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 incluídas quando um evento do Blob Armazenamento é publicado num organizador de eventos, consulte O Blob do Azure Armazenamentocomo origem da Grelha do Evento.

Executar a Função Azure localmente no depurador

Para testar o seu código da Função Azure localmente, tem de enviar manualmente um pedido HTTP que acione o evento. Pode publicar o pedido com uma ferramenta como o Postman.

Na parte superior do ficheiro de classe da sua Função do Azure, encontra-se um ponto final de URL que pode utilizar para testar no ambiente local. Publicar o pedido com este URL aciona 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 enviar para este ponto final é um pedido simulado. Não envia nem recebe dados da sua conta do Azure Armazenamento Conta.

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

  1. No Postman, crie um novo pedido.

  2. Colar o URL mostrado acima no campo do URL do pedido, substituindo o nome da sua função por e removendo as {functionname} chavetas. Certifique-se de que o verbo do pedido está definido para OBTER.

    Captura de ecrã a mostrar como especificar o URL local para o acionador de eventos no Postman

  3. Adicione o cabeçalho Tipo de Conteúdo e defina-o como aplicação/json.

  4. Adicione o cabeçalho de tipo de evento em primeiro plano e defina-o como Notificação.

    Captura de ecrã a mostrar a configuração do cabeçalho do pedido local para ativar evento

  5. No Postman, especifique o corpo do pedido, com o tipo de corpo definido para JSON e o formato para raw . O exemplo seguinte simula um pedido Copiar Blob. Substitua os valores de espaço entre parênteses angulares pelos seus próprios valores. Tenha em atenção que não é necessário alterar valores de data/hora ou identificador, uma vez que 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 quebra pretendido no código e prima F5 para executar o depurador.

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

Quando envia o pedido, a Grelha de Eventos liga para a sua Função do Azure e pode depurar a mesma normalmente. Para obter informações e exemplos adicionais, consulte Publicar manualmente o pedido na documentação funções do Azure.

O pedido que aciona o evento é simulado, mas a Função Azure que é executada quando o evento escreve informações de registo num novo blob na sua conta de armazenamento. Pode verificar os conteúdos do blob e ver a hora da última modificação no portal do Azure, conforme apresentado na imagem seguinte:

Captura de ecrã a mostrar os conteúdos do blob de registo no portal do Azure

Publicar a Função Azure

Depois de ter testado a sua Função do Azure localmente, o passo seguinte é publicar a Função Azure na Aplicação de Funções do Azure que criou anteriormente. A função tem de ser publicada para que possa configurar a Grelha de Eventos para enviar eventos que ocorrem na conta de armazenamento até ao ponto final da função.

Siga estes passos para publicar a função:

  1. No Explorador de Soluções, selecione sem selecionar (ou clique com o botão direito do rato) o seu projeto de Funções do Azure e selecione Publicar.

  2. Na janela Publicar, selecione O Azure como destino e, em seguida, selecione Seguinte.

  3. Selecione Aplicação de Funções do Azure (Windows) como destino específico e, em seguida, selecione Seguinte.

  4. No separador Instância de funções, selecione a sua subscrição no menu superior e, em seguida, localize a sua Aplicação de Funções do Azure na lista de aplicações de funções disponíveis.

  5. Certifique-se de que a caixa de verificação Executar a partir do ficheiro de pacote está selecionada.

  6. Selecione Concluir para se preparar para publicar a função.

  7. Na página Publicar, verifique se a configuração está correta. Se vir um aviso a indicar que a dependência do serviço da Aplicação Informações 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 na Aplicação de Funções do Azure que criou anteriormente.

    Captura de ecrã a mostrar a página para publicar a Função Azure a partir Visual Studio

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

Subscrever eventos de re hidratação blob a partir de uma conta de armazenamento

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

Quando cria a subscrição do evento, pode filtrar os eventos que são enviados para o organizador do evento. Os eventos a capturar ao re hidratar um blob a partir da escaleira Arquivo são a Microsoft.Armazenamento. BlobTierChanged,correspondente a uma operação Set Blob Tier e Microsoft.Armazenamento. BlobCreated events, corresponding to a Copy Blob operation. Consoante o seu cenário, poderá pretender lidar com apenas 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 os blobs a re hidratar a partir da escalagem de Arquivo.

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

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

  4. Selecione Criar Subscrição de Evento.

  5. Na página Criar Subscrição do Evento, na secção Detalhes da subscrição do evento, forneça um nome para a subscrição do evento.

  6. Na secção Detalhes do tópico, forneça um nome para o tópico do sistema. O tópico do sistema representa um ou mais eventos publicados pelo Azure Armazenamento. Para obter mais informações sobre tópicos do sistema, consulte tópicos do sistema na Grelha de Eventos do Azure.

  7. Na secção Tipos de Evento, selecione os eventos Blob Criado e Escalão Blob Alterado. Dependendo de como optar por re hidratar um blob a partir da escalão Arquivo, um destes dois eventos será ativado.

    Captura de ecrã a mostrar como selecionar tipos de eventos para eventos de re hidratação blob no portal do Azure

  8. Na secção Detalhes do ponto final, selecione Função do Azure no menu superior.

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

    Captura de ecrã a mostrar como selecionar uma Função do Azure como ponto final de uma subscrição da Grelha do Evento

  10. Selecione o botão Criar para criar a subscrição do evento e começar a enviar eventos para o handler de eventos da Função do Azure.

Para saber mais sobre subscrições de eventos, consulte Conceitos de Grelha de Eventos do Azure.

Testar o alça de evento da Função Azure

Para testar a Função do Azure, pode ativar um evento na conta de armazenamento que contém a subscrição do evento. A subscrição do evento que criou anteriormente está a filtrar por dois eventos, Microsoft.Armazenamento. BlobCreated e Microsoft.Armazenamento. BlobTierChanged. Quando um destes eventos é ativado, a função Azure é ativada.

A Função Azure apresentada neste artigo escreve num blob de registo em dois cenários:

  • Quando o evento for Microsoft.Armazenamento. BlobCreated e a operação API é Copiar Blob.
  • Quando o evento for Microsoft.Armazenamento. BlobTierChanged e a operação API é Definir Escalão de Blob.

Para saber como testar a função ao re hidratar um blob, consulte um destes dois procedimentos:

Após a re hidratação estar concluída, o blob de registo é escrito no mesmo contentor que o blob que re hidratou. Por exemplo, depois de re hidratar um blob com uma operação de cópia, pode ver no portal do Azure que o blob de origem original permanece na escalão Arquivo, que o blob de destino totalmente re hidratado aparece na escalão online de destino e o blob de registo criado pela Função Azure também aparece na lista.

Captura de ecrã a mostrar o blob original na escalagem Arquivo, o blob re hidratado na escalagem de Atalho e o blob de registo escrito pelo organizador de eventos

Tenha em atenção que re hidratar um blob pode demorar até 15 horas, dependendo da definição de prioridade de re hidratação. Se definir a prioridade da re hidratação para Alto ,a re hidratação pode ser concluída em menos de uma hora para blobs com menos de 10 GB de tamanho. No entanto, a re hidratação de alta prioridade tem um custo mais elevado. Para obter mais informações, consulte Overview of blob re hidraation from the Archive tier.

Sugestão

Embora o objetivo deste how-to seja lidar com estes eventos no contexto da re hidratação blob, para efeitos de teste também poderá ser útil observar estes eventos em resposta ao carregamento de um blob ou à alteração da escalagem de um blob online(porexemplo, de Hot to Cool), porque o evento é ativado imediatamente.

Para obter mais informações sobre como filtrar eventos na Grelha de Eventos, consulte Como filtrar eventos para a Grelha de Eventos do Azure.

Consulte também