Criar e executar códigos do .NET Framework a partir de fluxos de trabalho Standard nos Aplicativos Lógicos do Azure

Artigo
09/06/2024

Aplica-se a: Aplicativos Lógicos do Azure (Standard)

Para as soluções de integração nas quais é necessário criar e executar o código do .NET a partir do fluxo de trabalho do aplicativo lógico Standard, você pode usar o Visual Studio Code com a extensão Aplicativos Lógicos do Azure (Standard). Essa extensão oferece 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 o código junto com seus fluxos de trabalho. Não são necessários outros planos de serviço.
Suporte a cenários de migração do BizTalk Server para que você possa elevar e transferir 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 da 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
Modelagem de mensagens para mensagens de saída para outro sistema, como uma API
Cálculos

Essa funcionalidade não é adequada para cenários como o seguinte:

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

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

Pré-requisitos

Uma conta e uma assinatura do Azure. Se você não tem uma assinatura, inscreva-se em uma conta gratuita do Azure.
A extensão mais recente do Visual Studio Code com a extensão Aplicativos Lógicos do Azure (Standard). Para atender a esses requisitos, consulte os pré-requisitos para Criar fluxos de trabalho Standard nos Aplicativos Lógicos do Azure de locatário único com o Visual Studio Code.
- No momento, o recurso de funções personalizadas está disponível apenas no Visual Studio Code, executado em um sistema operacional Windows.
- Atualmente, a funcionalidade de funções personalizadas dá suporte à chamada do .NET Framework e do .NET 8 para fluxos de trabalho de aplicativo lógico hospedados no Azure.
Uma pasta local a ser usada para criar seu projeto de código

Limitações

No momento, 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. Use a ação interna denominada Chamar uma função local neste aplicativo lógico, para selecionar em suas funções personalizadas implantadas e executar seu código. As ações subsequentes em seu fluxo de trabalho podem referenciar as saídas dessas funções, como em qualquer outro fluxo de trabalho. Exiba o histórico de execução, as entradas e as saídas da ação interna.
As funções personalizadas usam um trabalho 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 trabalho, use as mesmas versões de pacote referenciadas pelo trabalho. Para obter a lista completa de pacotes e versões referenciadas pelo trabalho, consulte Dependências de trabalho e pacote.

Criar um projeto de código

A mais recente extensão do Aplicativos Lógicos do Azure (Standard) para o 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. Esse modelo de projeto cria um arquivo de espaço de trabalho e dois exemplos de projetos: um projeto para escrever seu código e outro projeto para criar seus fluxos de trabalho.

Observação

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 aberta na barra de ferramentas da seção Espaço de Trabalho, no menu Aplicativos Lógicos do Azure, selecione Criar um novo espaço de trabalho de aplicativo lógico.
Na caixa Selecionar pasta, navegue e selecione a pasta local criada para seu projeto.
Quando a caixa de solicitação Criar novo espaço de trabalho do aplicativo lógico for exibida, forneça um nome para o espaço de trabalho:

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

Siga as instruções subsequentes para fornecer os seguintes valores de exemplo:

Item	Valor de exemplo
Nome da função para o seu projeto de funções do .NET	WeatherForecast
Nome do namespace para o projeto de funções do .NET	Contoso.Enterprise
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	MyWorkflow

Selecione Abrir na janela atual.

Após a conclusão dessa etapa, o Visual Studio Code criará seu espaço de trabalho, que inclui um projeto de funções do .NET e um projeto de aplicativo lógico, por padrão, por exemplo:

Captura de tela mostrando o Visual Studio Code com o espaço de trabalho criado.

Nó	Descrição
*<workspace-name>*	Contém o projeto de funções do .NET e o projeto de fluxo de trabalho do aplicativo lógico.
Funções	Contém os artefatos do seu projeto de funções do .NET. Por exemplo, o arquivo *<function-name* >.cs** é o arquivo de código no qual você pode criar seu código.
LogicApp	Contém os artefatos do seu projeto de aplicativo lógico, incluindo um fluxo de trabalho em branco.

Escreva seu código

Em seu espaço de trabalho, expanda o nó Functions, se ainda não estiver expandido.

Abra o arquivo <function-name>.cs, que se chama WeatherForecast.cs neste exemplo.

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

Nome do Namespace
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 Run padrão que você pode usar para começar. Esse método de amostraRun demonstra alguns dos recursos disponíveis com o recurso de funções personalizadas, como a passagem de diferentes entradas e saídas, incluindo tipos complexos de .NET.

O arquivo <function-name>.cs também inclui a interface ILogger, que fornece suporte aos eventos de registro em log em um recurso do Application Insights. Envie informações de rastreamento para o Application Insights e armazene 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 da função de exemplo pelo seu próprio código e edite o método Run padrão para seus próprios cenários. Ou você pode copiar a função, incluindo a declaração [FunctionName("<*function-name*>")], e renomear a função com um nome exclusivo. Você pode então editar a função renomeada para atender às suas necessidades.

Esse exemplo continua com o código de exemplo sem nenhuma alteração.

Compilar e criar seu código

Após terminar de escrever seu código, compile para garantir que não haja erros de compilação. Seu projeto de funções do .NET inclui automaticamente tarefas de compilação, que compilam e, em seguida, adicionam seu código à pasta lib\custom em seu projeto de aplicativo lógico, onde os fluxos de trabalho procuram funções personalizadas para execução. Essas tarefas colocam os assemblies na pasta lib\custom\net472 ou lib\custom\net8, com base na sua versão do .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 abrirá uma janela de terminal com um prompt de comando.
Na janela Terminal, no prompt de comando, insira dotnet restore.

O Visual Studio Code analisa seus projetos e determina se eles estão atualizados.
Quando o prompt de comando for exibido novamente, insira dotnet build. Ou, no menu Terminal, selecione Executar tarefa. Na lista de tarefas, selecione build (Funções).

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 do .NET. Confirme se a subpasta denominada net472 ou net8, respectivamente, contém os arquivos de assembly (DLL) necessários para executar seu código, incluindo um arquivo chamado <nome-da-função>.dll.
- No seu 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 do 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 exemplos de assemblies gerados e outros arquivos no projeto do aplicativo lógico:

Chame seu código a partir de um fluxo de trabalho

Após a confirmação da compilação do código e de 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.

No seu espaço de trabalho, em LogicApp, expanda o nó <workflow-name>, abra o menu de atalho para workflow.json e selecione Abrir Designer.

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

O painel de informações da ação será aberto à direita.
Examine e confirme se o valor do parâmetro Nome da Função está definido para a função que você deseja executar. Examinar ou alterar quaisquer outros valores de parâmetro que sua função utiliza.

Depurar seu código e fluxo de trabalho

Repita as etapas a seguir para iniciar o emulador de armazenamento Azurite três vezes: uma vez para cada um dos seguintes serviços de Armazenamento do Microsoft Azure:
- Serviço Blob do Azure
- Serviço de Fila do Azure
- Serviço Tabela do Azure
1. No menu Exibir do Visual Studio Code, selecione Paleta de Comandos.
2. No prompt que aparece, encontre e selecione Azurite: Iniciar Serviço de Blobs.
3. Na lista de diretórios de trabalho exibida, selecione LogicApp.
4. Repita essas etapas para Azurite: Iniciar Serviço de Fila e Azurite: Iniciar Serviço de Tabela.
Você será bem-sucedido quando a barra de tarefas do Visual Studio Code na parte inferior da tela mostrar 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 do Visual Studio Code, 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 depois Reproduzir (seta verde).
  
  A janela Terminal será aberta e mostrará o processo de depuração iniciado. A janela Console de depuração aparecerá e mostrará os status da depuração. Na parte inferior do Visual Studio Code, a barra de tarefas ficará laranja, indicando que o depurador .NET foi carregado.
Anexe o depurador ao seu projeto de funções do .NET seguindo estas etapas, com base em seu código:

Projetos do .NET 8
1. No menu Exibir do Visual Studio Code, selecione Paleta de Comandos.
2. Na paleta de comandos, localize e selecione Depurar: Anexar a um processo do .NET 5+ ou .NET Core.
3. Na lista, localize e selecione o processo dotnet.exe. Se houver vários processos dotnet.exe, selecione o processo que tem o seguinte caminho:
  
  <nome-do-drive>:\Users<nome-de-usuário.azure-functions-core-tools>\Functions\ExtensionBundles\Microsoft.Azure.Functions.ExtensionBundle.Workflows<versão-do-pacote-da-extensão>\CustomCodeNetFxWorker\net8\Microsoft.Azure.Workflows.Functions.CustomCodeNetFxWorker.dll
Projetos do .NET Framework

Na lista Executar e Depurar, selecione Anexar ao Functions do .NET (Functions) se ainda não estiver selecionado, depois selecione Reproduzir (seta verde).
Para definir qualquer ponto de interrupção, na definição da função (<function-name>.cs) ou na definição do fluxo de trabalho (workflow.json), encontre o número da linha na qual deseja o ponto de interrupção e selecione a coluna à esquerda, por exemplo:
Para executar manualmente o gatilho Solicitar em seu fluxo de trabalho, abra a página Visão geral do fluxo de trabalho.
1. No projeto do 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ê quiser iniciar manualmente o fluxo de trabalho. Em Propriedades do Fluxo de Trabalho, o valor URL da Chamada de Retorno é a URL de um ponto de extremidade que pode ser chamado criado pelo gatilho Solicitar em seu fluxo de trabalho. Você pode enviar solicitações a essa URL para disparar seu fluxo de trabalho a partir de outros aplicativos, inclusive outros fluxos de trabalho de aplicativos lógicos.
Na barra de ferramentas da página Visão geral, selecione Executar gatilho.

Após o início da execução do fluxo de trabalho, o depurador ativa 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.

Implantar o código

Implante as suas funções personalizadas da mesma maneira que implanta seu projeto de aplicativo lógico. Independentemente de você implantar a partir do Visual Studio Code ou usar um processo de DevOps de CI/CD, certifique-se de criar seu código e de que todos os assemblies dependentes existam na pasta do seguinte projeto do 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, confira Implantar os fluxos de trabalho Standard do Visual Studio Code no Azure.

Solução de problemas

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

No designer do 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 Tarefa>criar Funções.

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

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

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

O pacote não foi importado corretamente

Se a janela Saída mostrar um erro semelhante à seguinte mensagem, verifique se você tem o .NET 6.0 ou posterior instalado. Se você tiver essa versão instalada, experimente desinstalar e depois 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 na 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 Run do seu código, acrescente o seguinte parâmetro:

string parameter1 = null

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

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

Próximas etapas

Criar fluxos de trabalho Standard com Visual Studio Code

Compartilhar via