Share via

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

  • Artigo

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 Framework 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 Framework 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

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.

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.

  1. Abra o Visual Studio Code. Na Barra de Atividades, selecione o ícone do Azure. (Teclado: Shift+Alt+A)

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

    Screenshot shows Visual Studio Code, Azure window, Workspace section toolbar, and selected option for Create new logic app workspace.

  3. Na caixa Selecionar pasta, navegue e selecione a pasta local criada para seu projeto.

  4. 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:

    Screenshot shows Visual Studio Code with prompt to enter workspace name.

    Este exemplo continua com MyLogicAppWorkspace.

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

    Screenshot shows Visual Studio Code with prompt to select project template for logic app workspace.

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

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

  7. 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 e um projeto de aplicativo lógico, por padrão, por exemplo:

    Screenshot shows Visual Studio Code with created workspace.

    Nó Descrição
    <workspace-name> Contém o projeto de função e o projeto de fluxo de trabalho do aplicativo lógico.
    Funções Contém os artefatos do seu projeto de função. 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

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

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

    <...>

}

  3. 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ção 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.

  1. No Visual Studio Code, no menu Terminal, selecione Novo Terminal.

  2. Na lista de diretórios de trabalho exibida, selecione Funções como seu diretório de trabalho atual para o novo terminal.

    Screenshot shows Visual Studio Code, prompt for current working directory, and selected Functions directory.

    O Visual Studio Code abrirá uma janela de terminal com um prompt de comando.

  3. Na janela Terminal, no prompt de comando, insira dotnet restore.

    O Visual Studio Code analisa seus projetos e determina se eles estão atualizados.

    Screenshot shows Visual Studio Code, Terminal window, and completed dotnet restore command.

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

  5. 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. Confirme se a subpasta chamada net472 contém os arquivos de vários conjuntos (DLL) necessários para executar seu código, incluindo um arquivo chamado <function-name>.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:

    Screenshot shows Visual Studio Code and logic app workspace with function project and logic app project, now with the generated assemblies and other required files.

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.

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

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

    Screenshot shows Visual Studio Code, workflow designer, and default workflow with trigger and actions.

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

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

    Screenshot shows Visual Studio Code taskbar with Azure Blob Service, Azure Queue Service, and Azure Table Service running.

  2. Na Barra de Atividades do Visual Studio Code, selecione Executar e Depurar. (Teclado: Ctrl+Shift+D)

    Screenshot shows Visual Studio Code Activity Bar with Run and Debug selected.

  3. Na lista Executar e Depurar, selecione Anexar ao aplicativo lógico (LogicApp), se ainda não estiver selecionado, e depois Reproduzir (seta verde).

    Screenshot shows Run and Debug list with Attach to logic app selected and Play button selected.

    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.

  4. Na lista Executar e Depurar, selecione Anexar às Funções .NET (Funções) e, em seguida, Reproduzir (seta verde).

    Screenshot shows Run and Debug list with Attach to NET Functions selected and Play button selected.

  5. 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:

    Screenshot shows Visual Studio Code and the open function code file with a breakpoint set for a line in code.

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

      Screenshot shows Visual Studio Code and workflow's Overview page opened.

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

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

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

    Screenshot shows Visual Studio Code and finished workflow run.

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 lib/custom/net472 do projeto do aplicativo lógico antes de implantar. 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 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.

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]

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