Criar e executar código .NET de fluxos de trabalho Padrão no Aplicativos Lógicos do Azure usando o Visual Studio Code

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

Quando o seu cenário de integração precisar de tarefas personalizadas ou lógica além das operações internas e conectores no Aplicativos Lógicos do Azure, crie e execute código .NET como funções personalizadas em seus fluxos de trabalho padrão. Seu fluxo de trabalho pode executar tarefas como análise personalizada, validação ou até mesmo aplicar regras de negócios. Usando essa funcionalidade, você pode implementar cenários como as seguintes tarefas:

Personalizar a implementação da lógica de negócios.
Personalize a análise para extrair informações de uma mensagem de entrada.
Execute a validação de dados e transformações simples.
Execute cálculos.
Formate mensagens de saída enviadas para outro sistema, como uma API.

Este guia mostra como escrever e executar seu próprio código .NET diretamente em fluxos de trabalho Standard usando Visual Studio Code. Você aprenderá a criar, depurar e implantar funções locais usando Visual Studio Code para que você possa manter a orquestração personalizada de código e fluxo de trabalho unida, depurá-las em uma sessão e implantá-las como uma única solução.

Observação

O código de .NET embutido personalizado não é adequado para os seguintes cenários:

Executando processos que podem exceder 10 minutos.
Realize tentativas de transformação de mensagens e dados em grande escala.
Execute cenários complexos de processamento em lote e desagrupamento.
Usando componentes de pipeline do servidor BizTalk que implementam o streaming.

Para obter mais informações, consulte Limitações.

Pré-requisitos

Uma conta Azure e uma assinatura. Get uma conta de Azure gratuita.
O Visual Studio Code mais recente com a extensão Aplicativos Lógicos do Azure (Standard).

Para pré-requisitos, consulte Criar fluxos de trabalho padrão em Aplicativos Lógicos do Azure de locatário único com o Visual Studio Code.

A 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 em 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, permitindo migrar investimentos personalizados em .NET do ambiente local para a nuvem.
Uma pasta local a ser usada para seu projeto de código.

Limitações

Você pode usar a funcionalidade de funções personalizadas apenas em Visual Studio Code em execução no Windows. Essa funcionalidade dá suporte ao uso do .NET Framework e do .NET 8 para fluxos de trabalho do aplicativo lógico Standard implantados e hospedados em Azure.
Você não pode usar funções personalizadas de criação no portal do Azure. No entanto, para trabalhar com saídas de funções personalizadas em seu fluxo de trabalho, siga estas etapas:
1. Depois de implantar suas funções no Azure, siga as etapas em Chamar seu código de um fluxo de trabalho no portal do Azure.
2. Adicione a ação interna chamada Chamar uma função local neste aplicativo lógico ao fluxo de trabalho. Selecione as funções personalizadas implantadas desejadas e execute seu código.
3. Use ações subsequentes do fluxo de trabalho para referenciar as saídas de funções personalizadas, assim como em qualquer outro fluxo de trabalho. Exiba o histórico de execução, as entradas e as saídas da ação interna.

Para obter limitações gerais, consulte Limits e referência de configuração para Aplicativos Lógicos do Azure.

1: Criar um projeto de código

A extensão Aplicativos Lógicos do Azure (Standard) 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 workspace e dois projetos de exemplo: 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.

Para criar um projeto de código, siga estas etapas:

Em Visual Studio Code, faça login na sua conta do Azure.

Se a entrada demorar mais do que o normal, Visual Studio Code solicitará que você entre por meio de um site de autenticação Microsoft fornecendo um código de dispositivo. Para entrar usando o código em vez disso, siga estas etapas:
1. Selecione Usar Código do Dispositivo e, em seguida, selecione Copiar &Abrir.
2. Selecione Abrir Link para abrir uma nova janela do navegador e continuar para o site de autenticação.
3. Na página Entrar na sua conta, insira seu código de autenticação e selecione Avançar.
Na Barra de Atividades, selecione o ícone Azure.
Na janela Azure, vá para a seção Workspace. Mova o ponteiro sobre a área de título para que a barra de ferramentas seja exibida.
No menu do Aplicativos Lógicos do Azure, selecione Criar novo espaço de trabalho do aplicativo lógico.
Na janela Selecionar Pasta , navegue até a pasta do projeto local, selecione a pasta e selecione.
Na janela Criar novo espaço de trabalho do aplicativo lógico, no prompt Nome do workspace, insira um nome para seu espaço de trabalho e pressione Enter.

Este exemplo usa weather-app como o nome do workspace:

Este exemplo usa weather-project como o nome do workspace.
Para a solicitação de selecionar um modelo para o seu novo projeto, escolha App lógica com projeto de código personalizado.
Para o prompt Selecione uma estrutura de destino prompt, selecione .NET Framework ou .NET 8.

Siga as instruções subsequentes para fornecer as informações a seguir.

Rápido	Valor de exemplo
Nome do Aplicativo Lógico	`weather-logic-app`
Nome da função para o seu projeto de funções .NET	`WeatherForecast`
Namespace para seu projeto de funções .NET	`Contoso.Enterprise`
Selecione um modelo para o primeiro fluxo de trabalho do projeto: - Fluxo de trabalho com estado - Fluxo de trabalho sem estado - Agente autônomo - Agente de conversação - Ignorar por enquanto	Fluxo de trabalho com estado
Nome do fluxo de trabalho	`weather-workflow`

Para selecionar como você deseja abrir o prompt do projeto, selecione Abrir na janela atual.

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

Captura de tela mostra o workspace criado com o projeto de aplicativo lógico e o projeto de funções .NET.

Na janela Do Explorer , observe as seguintes pastas em seu workspace:

Pasta	Descrição
< nome do workspace>	Contém o projeto de funções .NET e o projeto de fluxo de trabalho do aplicativo lógico.
< nome do aplicativo lógico>	Contém os arquivos e outros artefatos para seu projeto de aplicativo lógico. Por exemplo, o arquivo workflow.json é o arquivo de definição de fluxo de trabalho no qual você pode criar seu fluxo de trabalho.
< nome da função>	Contém os arquivos e outros artefatos para seu projeto de funções .NET. Por exemplo, o arquivo <function-name* >.cs* é o arquivo de código no qual você pode criar seu código.

Para o prompt Habilitar conectores para Azure para Aplicativos Lógicos <logic-app-name>, selecione Usar conectores do Azure.
Para o prompt Select subscription, selecione a assinatura do Azure desejada.
Para o prompt Selecionar um grupo de recursos para novos recursos , selecione o grupo de recursos desejado ou Crie um novo grupo de recursos.
Para o Selecione um local para novos recursos prompt, selecione a região Azure para implantação.

Para o método de autenticação Select para conectores Azure, selecione o tipo de autenticação a ser usado para conexões que precisam de autenticação.

Tipo de autenticação	Descrição
Identidade gerenciada	Selecione Identidade de Serviço Gerenciada para usar a identidade atribuída pelo sistema ou atribuída pelo usuário no recurso do aplicativo lógico. Por padrão, os recursos do aplicativo lógico Standard já têm a identidade atribuída pelo sistema habilitada. No entanto, você precisa configurar a identidade com acesso à função no recurso de destino, além de quaisquer outros requisitos. Para obter mais informações, consulte Atribuir acesso baseado em função a uma identidade gerenciada.
Chaves de conexão	Configure o acesso ao recurso de destino usando cadeias de conexões e chaves de acesso.

Tipo de autenticação

Descrição

Identidade gerenciada

Selecione Identidade de Serviço Gerenciada para usar a identidade atribuída pelo sistema ou atribuída pelo usuário no recurso do aplicativo lógico.

Por padrão, os recursos do aplicativo lógico Standard já têm a identidade atribuída pelo sistema habilitada. No entanto, você precisa configurar a identidade com acesso à função no recurso de destino, além de quaisquer outros requisitos.

Para obter mais informações, consulte Atribuir acesso baseado em função a uma identidade gerenciada.

Chaves de conexão

Configure o acesso ao recurso de destino usando cadeias de conexões e chaves de acesso.

Depois de concluir essas etapas, continue para a próxima seção para que você possa criar seu código.

2: Escrever seu código

Na janela do Explorer, expanda a pasta do projeto de função e abra o arquivo da função <function-name>.cs.

Esse arquivo contém código de exemplo e elementos de código específicos com valores fornecidos anteriormente.

Neste exemplo, o arquivo de função WeatherForecast.cs contém estes elementos de código com valores de exemplo:

Elemento de código	Valor
Nome do Namespace	`Contoso.Enterprise`
Nome da classe	`WeatherForecast`
Nome da função	`WeatherForecast`
Parâmetros de função	`zipcode`, `temperatureScale`
Tipo de retorno	`Task`
Tipo complexo	`Weather`

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. Este método Run de exemplo demonstra alguns recursos disponíveis com o recurso de funções personalizadas, como passar entradas e saídas diferentes, incluindo tipos complexos de .NET.

O arquivo <function-name>.cs também inclui a interface ILogger, que fornece suporte para o registro de eventos em um recurso do Application Insights. Você pode enviar informações de rastreamento para o Application Insights e armazenar essas informações 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 cenários específicos. 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.

Este exemplo continua com o código de exemplo original, supondo que não haja alterações.

3: Compilar e criar seu código

Depois de concluir a gravação do código, compile-o para garantir que não existam erros de build. Seu projeto de funções .NET inclui automaticamente tarefas de build, que compilam e adicionam seu código à pasta lib\custom no projeto do aplicativo lógico em que os fluxos de trabalho procuram funções personalizadas para execução. Dependendo da versão .NET, essas tarefas colocam os assemblies na pasta lib\custom\net472 ou lib\custom\net8.

Siga estas etapas:

Em Visual Studio Code, na Barra de Atividades, selecione Explorer.
Na janela Explorer, abra o menu de contexto da pasta do projeto de funções e selecione Compilar projeto de funções.

A tarefa de compilação é executada para o projeto de funções. Se o build for bem-sucedido, a janela Terminalmostrará uma mensagem de build 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: <your-logic-app>>lib\custom>net472 ou net8, com base na sua versão .NET. Confirme se a subpasta chamada net472 ou net8 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: <seu aplicativo de lógica>>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:

4: Chame seu código de um fluxo de trabalho

Depois de confirmar que seu código é compilado e seu projeto de aplicativo lógico contém os arquivos necessários para que seu código seja executado, configure seu fluxo de trabalho para chamar seu código.

Na janela Explorer, expanda workspace-name, logic-app-name e, em seguida, workflow-name.

Abra o menu de atalho para workflow.jsone selecione Abrir designer.

O designer de fluxo de trabalho é aberto e mostra o fluxo de trabalho padrão com o seguinte gatilho e ações:

Operação	Descrição
Gatilho	O gatilho de solicitação interno chamado Quando uma solicitação HTTP é recebida.
Ação	A ação integrada chamada Chamar uma função local neste aplicativo lógico.
Ação	A ação Response integrada chamada Response é usada para responder ao chamador apenas quando se utiliza o gatilho Request.

No designer, selecione a ação chamada Chamar uma função local neste aplicativo lógico.

O painel de informações da ação é aberto para que você possa configurar a chamada de função personalizada, por exemplo:
Examine e confirme se o valor do parâmetro de nome da função está definido como a função que você deseja executar. Examinar ou alterar quaisquer outros valores de parâmetro que sua função utiliza.

5: Depurar seu código e fluxo de trabalho

Para cada um dos seguintes serviços de Armazenamento do Azure, inicie o emulador de armazenamento do Azurite:
- Serviço de Blob de Azure
- Serviço de Fila do Azure
- Serviço de Tabela Azure
1. No menu Visual Studio Code View, selecione Command Palette.
2. No prompt que aparece, selecione Azurite: Iniciar Serviço de Blob na lista.
3. Na lista de diretórios de trabalho exibida, selecione seu aplicativo lógico.
4. Repita essas etapas para Azurite: Iniciar Serviço de Fila e Azurite: Iniciar Serviço de Tabela.
Se você tiver êxito, a barra de tarefas Visual Studio Code na parte inferior da tela mostrará os três serviços de armazenamento em execução.
Anexe o depurador ao seu projeto de aplicativo lógico e ao projeto de funções .NET seguindo estas etapas:
1. Em Visual Studio Code, na Barra de Atividades, selecione Run e Depurar (teclado: Ctrl+Shift+D).
2. Na lista Executar e Depurar, selecione Executar/Depurar aplicativo lógico com função local (<seu aplicativo lógico>) e, em seguida, selecione Executar (seta verde).
  
  Os seguintes eventos ocorrem:
  - A janela Terminal será aberta e mostrará o processo de depuração iniciado.
  - A janela Console de Depuração é aberta e mostra o status de depuração.
  - Na parte inferior do Visual Studio Code, a barra de tarefas fica laranja, indicando que o depurador de .NET está carregado.
Para definir pontos de interrupção, na definição de função (<nome >.cs) ou definição de fluxo de trabalho (workflow.json), localize o número de linha onde você deseja o ponto de interrupção e selecione a coluna adjacente, por exemplo:
Para executar manualmente o gatilho Solicitação 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.
2. Na barra de ferramentas da página Visão geral, selecione Executar gatilho.
  
  Uma screenshot mostra o Visual Studio Code e a página de visão geral aberta do fluxo de trabalho.
  
  Após o início da execução do fluxo de trabalho, o depurador ativa seu primeiro ponto de interrupção.
3. 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.

6: Implantar seu código

Implante suas funções personalizadas da mesma maneira que implanta seu projeto de aplicativo lógico. Independentemente de implantar do Visual Studio Code ou usar um processo DevOps de CI/CD, compile seu código antes da implantação. Além disso, verifique se todos os assemblies dependentes existem 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.

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, verifique seu projeto de aplicativo lógico para ver se a pasta LogicApp\lib\custom está vazia. Se estiver vazio, no menu Terminal, selecione Executar Tarefa>build Functions.

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 anexou o processo de depurador 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, Reproduzir (triângulo verde).

O pacote não foi importado corretamente

Se a janela Saída mostrar um erro semelhante à mensagem a seguir, verifique se você tem pelo menos .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.

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)

Criar fluxos de trabalho de Logic Apps Standard com o Visual Studio Code

Comentários

Esta página foi útil?

Last updated on 2026-04-08