Criar e executar código .NET a partir de fluxos de trabalho padrão nos Aplicativos Lógicos do Azure

Artigo
09/06/2024

Aplica-se a: Aplicativos Lógicos do Azure (Padrão)

Para soluções de integração em que você precisa criar e executar código .NET a partir do fluxo de trabalho do aplicativo lógico Padrão, você pode usar o Visual Studio Code com a extensão Azure Logic Apps (Standard). Esta extensão fornece os seguintes recursos e benefícios:

Escreva seu próprio código criando funções que têm a flexibilidade e o controle para resolver seus problemas de integração mais desafiadores.
Depurar código localmente no Visual Studio Code. Percorra seu código e fluxos de trabalho na mesma sessão de depuração.
Implante código junto com seus fluxos de trabalho. Não são necessários outros planos de serviço.
Ofereça suporte a cenários de migração do BizTalk Server para que você possa elevar e deslocar investimentos personalizados do .NET do local para a nuvem.

Com a capacidade de escrever seu próprio código, você pode realizar cenários como os seguintes:

Implementação de lógica de negócios personalizada
Análise personalizada para extrair informações de uma mensagem de entrada
Validação de dados e transformações simples
Formatação de mensagens para mensagens de saída para outro sistema, como uma API
Cálculos

Esse recurso não é adequado para cenários como os seguintes:

Processos que levam mais de 10 minutos para serem executados
Grandes transformações de mensagens e dados
Cenários complexos de processamento em lote e desloteamento
Componentes de pipeline do BizTalk Server que implementam streaming

Para obter mais informações sobre limitações nos Aplicativos Lógicos do Azure, consulte Limites e configuração - Aplicativos Lógicos do Azure.

Pré-requisitos

Uma conta e subscrição do Azure. Se não tiver uma subscrição, inscreva-se numa conta do Azure gratuita.
O código mais recente do Visual Studio com a extensão Azure Logic Apps (Standard). Para atender a esses requisitos, consulte os pré-requisitos para Criar fluxos de trabalho padrão em aplicativos lógicos do Azure de locatário único com o Visual Studio Code.
- O recurso de funções personalizadas está atualmente disponível apenas no Visual Studio Code, em execução em um sistema operacional Windows.
- Atualmente, o recurso de funções personalizadas oferece suporte à chamada do .NET Framework e do .NET 8 para fluxos de trabalho de aplicativos lógicos hospedados no Azure.
Uma pasta local para usar para criar seu projeto de código

Limitações

Atualmente, a criação de funções personalizadas não está disponível no portal do Azure. No entanto, depois de implantar suas funções do Visual Studio Code no Azure, siga as etapas em Chamar seu código de um fluxo de trabalho para o portal do Azure. Você pode usar a ação interna chamada Chamar uma função local neste aplicativo lógico para selecionar entre suas funções personalizadas implantadas e executar seu código. As ações subsequentes em seu fluxo de trabalho podem fazer referência às saídas dessas funções, como em qualquer outro fluxo de trabalho. Você pode visualizar o histórico de execução, entradas e saídas da ação interna.
As funções personalizadas usam um trabalhador isolado para invocar o código no fluxo de trabalho do aplicativo lógico. Para evitar conflitos de referências de pacote entre seu próprio código de função e o trabalhador, use as mesmas versões de pacote referenciadas pelo trabalhador. Para obter a lista completa de pacotes e as versões referenciadas pelo trabalhador, consulte Dependências do trabalhador e do pacote.

Criar um projeto de código

A extensão mais recente dos Aplicativos Lógicos do Azure (Padrão) para Visual Studio Code inclui um modelo de projeto de código que fornece uma experiência simplificada para escrever, depurar e implantar seu próprio código com seus fluxos de trabalho. Este modelo de projeto cria um arquivo de espaço de trabalho e dois projetos de exemplo: um projeto para escrever seu código, o outro projeto para criar seus fluxos de trabalho.

Nota

Você não pode usar a mesma pasta de projeto para seu código e fluxos de trabalho.

Abra o Visual Studio Code. Na barra de atividades, selecione o ícone do Azure . (Teclado: Shift+Alt+A)
Na janela do Azure que se abre, na barra de ferramentas da seção Espaço de Trabalho, no menu Aplicativos Lógicos do Azure, selecione Criar novo espaço de trabalho de aplicativo lógico.
Na caixa Selecionar pasta, procure e selecione a pasta local que você criou para seu projeto.
Quando a caixa de prompt Criar novo espaço de trabalho do aplicativo lógico for exibida, forneça um nome para seu espaço de trabalho:

Este exemplo continua com MyLogicAppWorkspace.
Quando a caixa de prompt Selecione um modelo de projeto para seu espaço de trabalho de aplicativo lógico for exibida, selecione Aplicativo lógico com projeto de código personalizado.
Para fluxos de trabalho do aplicativo lógico Standard hospedado no Azure, siga o prompt para selecionar .NET Framework ou .NET 8.

Siga os prompts subsequentes para fornecer os seguintes valores de exemplo:

Item	Valor de exemplo
Nome da função para seu projeto de funções .NET	Previsão do tempo
Nome do namespace para seu projeto de funções .NET	Contoso.Empresa
Modelo de fluxo de trabalho: - Fluxo de trabalho com estado - Fluxo de trabalho sem estado	Fluxo de trabalho com estado
Nome do fluxo de trabalho	Meu fluxo de trabalho

Selecione Abrir na janela atual.

Depois de concluir esta etapa, o Visual Studio Code cria seu espaço de trabalho, que inclui um projeto de funções .NET e um projeto de aplicativo lógico, por padrão, por exemplo:

A captura de tela mostra o Visual Studio Code com o espaço de trabalho criado.

Nó	Description
*<nome do espaço de trabalho>*	Contém seu projeto de funções .NET e projeto de fluxo de trabalho de aplicativo lógico.
Funções	Contém os artefatos para seu projeto de funções .NET. Por exemplo, o *<arquivo de nome> da função.cs* é o arquivo de código onde você pode criar seu código.
LogicApp	Contém os artefatos para seu projeto de aplicativo lógico, incluindo um fluxo de trabalho em branco.

Escreva o seu código

No espaço de trabalho, expanda o nó Funções , se ainda não estiver expandido.

Abra o <arquivo function-name>.cs que é chamado WeatherForecast.cs neste exemplo.

Por padrão, esse arquivo contém código de exemplo que tem os seguintes elementos de código, juntamente com os valores de exemplo fornecidos anteriormente, quando apropriado:

Nome do espaço de nomes
Nome da classe
Nome da função
Parâmetros de função
Tipo de retorno
Tipo complexo

O exemplo a seguir mostra o código de exemplo completo:

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------

namespace Contoso.Enterprise
{
    using System;
    using System.Collections.Generic;
    using System.Threading.Tasks;
    using Microsoft.Azure.Functions.Extensions.Workflows;
    using Microsoft.Azure.WebJobs;
    using Microsoft.Extensions.Logging;

    /// <summary>
    /// Represents the WeatherForecast flow invoked function.
    /// </summary>
    public class WeatherForecast
    {

        private readonly ILogger<WeatherForecast> logger;

        public WeatherForecast(ILoggerFactory loggerFactory)
        {
            logger = loggerFactory.CreateLogger<WeatherForecast>();
        }

        /// <summary>
        /// Executes the logic app workflow.
        /// </summary>
        /// <param name="zipCode">The zip code.</param>
        /// <param name="temperatureScale">The temperature scale (e.g., Celsius or Fahrenheit).</param>
        [FunctionName("WeatherForecast")]
        public Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale)
        {

            this.logger.LogInformation("Starting WeatherForecast with Zip Code: " + zipCode + " and Scale: " + temperatureScale);

            // Generate random temperature within a range based on the temperature scale
            Random rnd = new Random();
            var currentTemp = temperatureScale == "Celsius" ? rnd.Next(1, 30) : rnd.Next(40, 90);
            var lowTemp = currentTemp - 10;
            var highTemp = currentTemp + 10;

            // Create a Weather object with the temperature information
            var weather = new Weather()
            {
                ZipCode = zipCode,
                CurrentWeather = $"The current weather is {currentTemp} {temperatureScale}",
                DayLow = $"The low for the day is {lowTemp} {temperatureScale}",
                DayHigh = $"The high for the day is {highTemp} {temperatureScale}"
            };

            return Task.FromResult(weather);
        }

        /// <summary>
        /// Represents the weather information for WeatherForecast.
        /// </summary>
        public class Weather
        {
            /// <summary>
            /// Gets or sets the zip code.
            /// </summary>
            public int ZipCode { get; set; }

            /// <summary>
            /// Gets or sets the current weather.
            /// </summary>
            public string CurrentWeather { get; set; }

            /// <summary>
            /// Gets or sets the low temperature for the day.
            /// </summary>
            public string DayLow { get; set; }

            /// <summary>
            /// Gets or sets the high temperature for the day.
            /// </summary>
            public string DayHigh { get; set; }
        }
    }
}

A definição de função inclui um método padrão Run que você pode usar para começar. Este método de exemplo Run demonstra alguns dos recursos disponíveis com o recurso de funções personalizadas, como passar entradas e saídas diferentes, incluindo tipos .NET complexos.

O <arquivo .cs nome da função> também inclui a ILogger interface, que fornece suporte para registrar eventos em um recurso do Application Insights. Você pode enviar informações de rastreamento para o Application Insights e armazenar essas informações junto com as informações de rastreamento de seus fluxos de trabalho, por exemplo:

private readonly ILogger<WeatherForecast> logger;

public WeatherForecast(ILoggerFactory loggerFactory)
{
    logger = loggerFactory.CreateLogger<WeatherForecast>();
}

[FunctionName("WeatherForecast")]
public Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale)
{

    this.logger.LogInformation("Starting WeatherForecast with Zip Code: " + zipCode + " and Scale: " + temperatureScale);

    <...>

}

Substitua o código de função de exemplo pelo seu próprio e edite o método padrão Run para seus próprios cenários. Ou, você pode copiar a função, incluindo a [FunctionName("<*function-name*>")] declaração, e, em seguida, renomear a função com um nome exclusivo. Em seguida, você pode editar a função renomeada para atender às suas necessidades.

Este exemplo continua com o código de exemplo sem alterações.

Compile e construa seu código

Depois de terminar de escrever o código, compile para garantir que não existam erros de compilação. Seu projeto de funções .NET inclui automaticamente tarefas de compilação, que compilam e adicionam seu código à pasta lib\custom em seu projeto de aplicativo lógico, onde os fluxos de trabalho procuram funções personalizadas para executar. Essas tarefas colocam os assemblies na pasta lib\custom\net472 ou lib\custom\net8 , com base na sua versão .NET.

No Visual Studio Code, no menu Terminal , selecione Novo Terminal.
Na lista de diretórios de trabalho exibida, selecione Funções como seu diretório de trabalho atual para o novo terminal.

O Visual Studio Code abre uma janela de terminal com um prompt de comando.
Na janela Terminal, no prompt de comando, digite dotnet restore.

O Visual Studio Code analisa seus projetos e determina se eles estão atualizados.
Depois que o prompt de comando reaparecer, digite dotnet build. Ou, no menu Terminal , selecione Executar tarefa. Na lista de tarefas, selecione build (Functions).

Se a compilação for bem-sucedida, a janela Terminal informará que a compilação foi bem-sucedida.
Confirme se os seguintes itens existem em seu projeto de aplicativo lógico:
- Em seu espaço de trabalho, expanda as seguintes pastas: LogicApp>lib\custom>net472 ou net8, com base na sua versão .NET. Confirme se a subpasta chamada net472 ou net8, respectivamente, contém os arquivos assembly (DLL) necessários para executar o código, incluindo um arquivo chamado< function-name>.dll.
- No espaço de trabalho, expanda as seguintes pastas: LogicApp>lib\custom<>function-name.> Confirme se a subpasta chamada <function-name> contém um arquivo function.json, que inclui os metadados sobre o código da função que você escreveu. O designer de fluxo de trabalho usa esse arquivo para determinar as entradas e saídas necessárias ao chamar seu código.
O exemplo a seguir mostra assemblies gerados de exemplo e outros arquivos no projeto de aplicativo lógico:

Chame seu código de um fluxo de trabalho

Depois de confirmar que o código é compilado e que o projeto do aplicativo lógico contém os arquivos necessários para a execução do código, abra o fluxo de trabalho padrão incluído no projeto do aplicativo lógico.

Em seu espaço de trabalho, em LogicApp, expanda o nó de nome> do< fluxo de trabalho, abra o menu de atalho para workflow.json e selecione Abrir Designer.

No designer de fluxo de trabalho que é aberto, o fluxo de trabalho padrão, incluído com seu projeto de aplicativo lógico, aparece com o seguinte gatilho e ações:
- O gatilho de solicitação interno chamado Quando uma solicitação HTTP é recebida
- A ação interna chamada Chamar uma função local neste aplicativo lógico
- A ação interna de Resposta chamada Resposta, que você usa para responder ao chamador somente quando usa o gatilho de Solicitação
Selecione a ação chamada Chamar uma função local neste aplicativo lógico.

O painel de informações da ação é aberto à direita.
Revise e confirme se o valor do parâmetro Nome da função está definido como a função que você deseja executar. Revise ou altere quaisquer outros valores de parâmetro usados pela sua função.

Depurar seu código e fluxo de trabalho

Repita as seguintes etapas para iniciar o emulador de armazenamento Azurite três vezes: uma vez cada para os seguintes serviços de Armazenamento do Azure:
- Serviço de Blob do Azure
- Serviço de Fila do Azure
- Serviço de Tabela do Azure
1. No menu Exibição de código do Visual Studio, selecione Paleta de comandos.
2. No prompt exibido, localize e selecione Azurite: Iniciar Serviço de Blob.
3. Na lista de diretórios de trabalho exibida, selecione LogicApp.
4. Repita estas etapas para Azurite: Start Queue Service e Azurite: Start Table Service.
Você é bem-sucedido quando a barra de tarefas Código do Visual Studio na parte inferior da tela mostra os três serviços de armazenamento em execução, por exemplo:
Anexe o depurador ao seu projeto de aplicativo lógico seguindo estas etapas:
1. Na barra de atividades de código do Visual Studio, selecione Executar e Depurar. (Teclado: Ctrl+Shift+D)
2. Na lista Executar e Depurar, selecione Anexar ao aplicativo lógico (LogicApp), se ainda não estiver selecionado, e selecione Reproduzir (seta verde).
  
  A janela Terminal é aberta e mostra o processo de depuração iniciado. A janela Debug Console é exibida e mostra os status de depuração. Na parte inferior do Visual Studio Code, a barra de tarefas fica laranja, indicando que o depurador .NET está carregado.
Anexe o depurador ao seu projeto de funções .NET seguindo estas etapas, com base no seu código:

Projetos .NET 8
1. No menu Exibição de código do Visual Studio, selecione Paleta de comandos.
2. Na paleta de comandos, localize e selecione Depurar: Anexar a um processo .NET 5+ ou .NET Core.
3. Na lista, localize e selecione o processo dotnet.exe . Se existirem vários processos dotnet.exe , selecione o processo que tem o seguinte caminho:
  
  <nome> da unidade:\Users<user-name.azure-functions-core-tools>\Functions\ExtensionBundles\Microsoft.Azure.Functions.ExtensionBundle.Workflows<extension-bundle-version>\CustomCodeNetFxWorker\net8\Microsoft.Azure.Workflows.Functions.CustomCodeNetFxWorker.dll
Projetos do .NET Framework

Na lista Executar e Depurar, selecione Anexar a Funções .NET (Funções), se ainda não estiver selecionada, e selecione Reproduzir (seta verde).
Para definir quaisquer pontos de interrupção, na sua definição de função (<nome> da função.cs) ou definição de fluxo de trabalho (workflow.json), localize o número da linha onde pretende o ponto de interrupção e selecione a coluna à esquerda, por exemplo:
Para executar manualmente o gatilho Solicitação no fluxo de trabalho, abra a página Visão geral do fluxo de trabalho.
1. No seu projeto de aplicativo lógico, abra o menu de atalho do arquivo workflow.json e selecione Visão geral.
  
  Na página Visão geral do fluxo de trabalho, o botão Executar gatilho está disponível para quando você deseja iniciar manualmente o fluxo de trabalho. Em Propriedades do Fluxo de Trabalho, o valor da URL de retorno de chamada é a URL de um ponto de extremidade chamável criado pelo gatilho Solicitação em seu fluxo de trabalho. Pode enviar pedidos para este URL para acionar o seu fluxo de trabalho a partir de outras aplicações, incluindo outros fluxos de trabalho de aplicações lógicas.
Na barra de ferramentas da página Visão geral , selecione Executar gatilho.

Depois que o fluxo de trabalho começar a ser executado, o depurador ativará seu primeiro ponto de interrupção.
No menu Executar ou na barra de ferramentas do depurador, selecione uma ação de depuração.

Após a conclusão da execução do fluxo de trabalho, a página Visão geral mostra a execução concluída e os detalhes básicos sobre essa execução.
Para revisar mais informações sobre a execução do fluxo de trabalho, selecione a execução concluída. Ou, na lista ao lado da coluna Duração , selecione Mostrar execução.

Implante seu código

Você pode implantar suas funções personalizadas da mesma forma que implanta seu projeto de aplicativo lógico. Se você implantar a partir do Visual Studio Code ou usar um processo de DevOps CI/CD, certifique-se de criar seu código e que todos os assemblies dependentes existam na seguinte pasta de projeto de aplicativo lógico antes de implantar:

.NET 4.7.2: pasta lib/custom/net472
.NET 8: pasta lib/custom/net8

Para obter mais informações, consulte Implantar fluxos de trabalho padrão do Visual Studio Code no Azure.

Resolução de problemas

Erro no painel de informações da ação

No designer de fluxo de trabalho, quando você seleciona a ação interna chamada Chamar uma função local neste aplicativo lógico, o painel de informações da ação mostra a seguinte mensagem:

Failed to retrieve dynamic inputs. Error details:

Nesse cenário, examine seu projeto de aplicativo lógico para verificar se a pasta LogicApp\lib\custom está vazia. Se estiver vazio, no menu Terminal, selecione Executar funções de compilação de tarefas>.

Nenhum processo com o nome especificado está em execução no momento

Se você receber essa mensagem de erro ao executar seu fluxo de trabalho, provavelmente terá o processo do depurador anexado ao .NET Functions, em vez de ao seu aplicativo lógico.

Para corrigir esse problema, na lista Executar e Depurar , selecione Anexar ao aplicativo lógico (LogicApp) e, em seguida, selecione Reproduzir (triângulo verde).

Pacote não importado corretamente

Se a janela Saída mostrar um erro semelhante à seguinte mensagem, certifique-se de que tem pelo menos o .NET 6.0 instalado. Se tiver esta versão instalada, tente desinstalar e, em seguida, reinstalar.

C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.targets(83,5): warning : The ExtensionsMetadataGenerator package was not imported correctly. Are you missing 'C:\Users\yourUserName\.nuget\packages\microsoft.azure.webjobs.script.extensionsmetadatagenerator\4.0.1\build\Microsoft.Azure.WebJobs.Script.ExtensionsMetadataGenerator.targets' or 'C:\Users\yourUserName\.nuget\packages\microsoft.azure.webjobs.script.extensionsmetadatagenerator\4.0.1\build\Microsoft.Azure.WebJobs.Script.ExtensionsMetadataGenerator.props'? [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] WeatherForecast -> C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\\bin\Debug\net472\WeatherForecast.dll C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : It was not possible to find any compatible framework version [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : The specified framework 'Microsoft.NETCore.App', version '6.0.0' was not found. [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : - Check application dependencies and target a framework version installed at: [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj]

Falhas de compilação

Se sua função não incluir variáveis e você criar seu código, a janela Saída poderá mostrar as seguintes mensagens de erro:

C:\Users\yourUserName\...\custom-code-project\Function\func.cs (24,64): error CS1031: Type expected [C:\Users\yourUserName\...\custom-code-project\Function\func.csproj]
C:\Users\yourUserName\...\custom-code-project\Function\func.cs (24,64): error CS1001: Identifier expected [C:\Users\yourUserName\...\custom-code-project\Function\func.csproj]

Build FAILED.

0 Warning(s)
2 Error(s)

Para corrigir esse problema, no método do Run código, acrescente o seguinte parâmetro:

string parameter1 = null

O exemplo a seguir mostra como a assinatura do Run método aparece:

public static Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale, string parameter1 = null)

Próximos passos

Criar fluxos de trabalho padrão com o Visual Studio Code

Partilhar via