Criar e executar código .NET a partir de fluxos de trabalho padrão no Azure Logic Apps usando o Visual Studio Code

Aplica-se a: Azure Logic Apps (Padrão)

Quando o teu cenário de integração precisar de tarefas personalizadas ou lógica para além das operações e conectores incorporados no Azure Logic Apps, cria e executa .NET código como funções personalizadas nos teus fluxos de trabalho padrão. O seu fluxo de trabalho pode então realizar tarefas como análise sintática personalizada, validação ou até aplicar regras de negócio. Ao utilizar esta capacidade, pode implementar cenários como as seguintes tarefas:

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

Este guia mostra como escrever e executar o seu próprio código .NET diretamente em fluxos de trabalho Standard, utilizando o Visual Studio Code. Aprendes a criar, depurar e implementar funções locais usando o Visual Studio Code para poderes manter código personalizado e orquestração de workflows juntos, depurá-los numa só sessão e implementá-los como uma única solução.

Nota

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

Processos em execução que podem ultrapassar os 10 minutos.
Tentar grandes transformações de mensagens e dados.
Execução de cenários complexos de agrupamento e desagrupamento.
Uso de componentes do pipeline do servidor BizTalk que implementam streaming.

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

Pré-requisitos

Uma conta Azure e subscrição. Crie uma conta Azure gratuita.
A mais recente versão do Visual Studio Code com a extensão Azure Logic Apps (Standard).

Para pré-requisitos, veja Criar workflows Standard em Azure Logic Apps de inquilino único com o Visual Studio Code.

A extensão oferece as seguintes capacidades 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.
- Suporta cenários de migração do BizTalk Server para que possa migrar investimentos personalizados em .NET do local para a cloud.
Uma pasta local para usar no seu projeto de código.

Limitações

Podes usar a funcionalidade de funções personalizadas apenas no Visual Studio Code a correr no Windows. Esta funcionalidade suporta o uso do .NET Framework e do .NET 8 para fluxos de trabalho de aplicações de lógica padrão implementados e alojados no Azure.
Não podes usar funções personalizadas de autoria no portal Azure. No entanto, para trabalhar com saídas de funções personalizadas no seu fluxo de trabalho, siga estes passos:
1. Depois de implementares as tuas funções para Azure, segue os passos em Chama o teu código a partir de um workflow para o portal Azure.
2. Adicione a ação incorporada chamada Chamar uma função local nesta aplicação lógica ao seu fluxo de trabalho. Seleciona as funções personalizadas implementadas que queres e executa o teu código.
3. Use ações subsequentes do fluxo de trabalho para referenciar os resultados das funções personalizadas, tal como pode fazer em qualquer outro fluxo de trabalho. Você pode visualizar o histórico de execução, entradas e saídas da ação interna.

Para limitações gerais, veja Limites e referência de configuração para Azure Logic Apps.

1: Criar um projeto de código

A extensão Azure Logic Apps (Standard) para Visual Studio Code inclui um modelo de projeto de código que proporciona uma experiência simplificada para escrever, depurar e implementar o seu próprio código com os seus fluxos de trabalho. Este modelo de projeto cria um ficheiro de espaço de trabalho e dois projetos de exemplo: um projeto para escrever o seu código e outro para criar os seus fluxos de trabalho.

Nota

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 estes passos:

Em Visual Studio Code, inicia sessão na tua conta Azure.

Se o início de sessão demorar mais do que o habitual, o Visual Studio Code pede-lhe para iniciar sessão através de um site de autenticação da Microsoft, fornecendo-lhe um código do dispositivo. Para iniciar sessão usando o código, siga estes passos:
1. Selecione Usar Código do Dispositivo e depois selecione Copiar & Abrir.
2. Selecione Abrir Link para abrir uma nova janela do navegador e continue até ao site de autenticação.
3. Na página Iniciar sessão na sua conta, introduza o seu código de autenticação e selecione Seguinte.
Na Barra de Atividade, selecione o ícone do Azure.
Na janela Azure, vai à secção Workspace. Mova o ponteiro sobre a área do título para que a barra de ferramentas apareça.
No menu Azure Logic Apps, selecione Criar novo espaço de trabalho de aplicação lógica.
Na janela Select Folder , navegue até à pasta local do projeto, selecione a pasta e depois Selecione.
Na janela Criar novo espaço de trabalho de aplicação lógica, introduza um nome para o seu espaço de trabalho no campo Nome do espaço de trabalho e, em seguida, prima Enter.

Este exemplo utiliza weather-app como nome do espaço de trabalho:

Este exemplo é usado weather-project como nome do espaço de trabalho.
Para selecionar um modelo para o seu novo prompt de projeto , selecione a aplicação Logic com projeto de código personalizado.
Para o prompt Select a target framework, selecione .NET Framework ou .NET 8.

Siga as indicações seguintes para fornecer a seguinte informação:

Prompt	Valor de exemplo
Nome da Aplicação Lógica	`weather-logic-app`
Nome da função para o seu projeto de funções .NET	`WeatherForecast`
Namespace para o teu projeto de funções .NET	`Contoso.Enterprise`
Selecione um modelo para o primeiro fluxo de trabalho do seu projeto: - Workflow com estado persistente - Fluxo de trabalho sem estado - Agente autónomo - Agente conversacional - Saltar por enquanto	Fluxo de trabalho com estado
Nome do fluxo de trabalho	`weather-workflow`

Para selecionar como deseja abrir o seu projeto , selecione Abrir na janela atual.

Depois de concluir este passo, o Visual Studio Code cria o seu espaço de trabalho, que inclui um projeto de funções .NET e um projeto de aplicação lógica, por defeito, por exemplo:

A screenshot mostra o espaço de trabalho criado com o projeto da aplicação lógica e o projeto de funções .NET.

Na janela do Explorador , note as seguintes pastas no seu espaço de trabalho:

Folder	Descrição
< nome do espaço de trabalho>	Contém tanto o teu projeto de funções .NET como o projeto de workflow de Logic App.
< logic-app-name>	Contém os ficheiros e outros artefactos do teu projeto de aplicação lógica. Por exemplo, o ficheiroworkflow.json é o ficheiro de definição do fluxo de trabalho onde podes construir o teu fluxo de trabalho.
< Nome da função>	Contém os ficheiros e outros artefactos do 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.

Para o prompt Enable connectors for Azure for Logic Apps <logic-app-name>, selecione Utilizar conectores do Azure.
Para o prompt Select subscription, seleciona a subscrição Azure que queres.
Para o aviso Selecionar um grupo de recursos para novos recursos, selecione o grupo de recursos que deseja ou Criar novo grupo de recursos.
Para o prompt Selecione um local para novos recursos, selecione a região Azure para implementação.

Para o método de autenticação Select para conectores Azure, selecione o tipo de autenticação a usar para ligações que necessitem de autenticação.

Tipo de autenticação	Descrição
Identidade gerenciada	Selecione Identidade de Serviço Gerido para usar a identidade atribuída pelo sistema ou pelo utilizador no recurso da sua aplicação lógica. Por defeito, os recursos da aplicação Standard Logic já têm a identidade atribuída ao sistema ativada. No entanto, tens de configurar a identidade com acesso de função no recurso de destino, além de quaisquer outros requisitos. Para mais informações, consulte Atribuir acesso baseado em função a uma identidade gerida.
Chaves de ligação	Configura o acesso ao recurso alvo usando strings de ligação e chaves de acesso.

Tipo de autenticação

Descrição

Identidade gerenciada

Selecione Identidade de Serviço Gerido para usar a identidade atribuída pelo sistema ou pelo utilizador no recurso da sua aplicação lógica.

Por defeito, os recursos da aplicação Standard Logic já têm a identidade atribuída ao sistema ativada. No entanto, tens de configurar a identidade com acesso de função no recurso de destino, além de quaisquer outros requisitos.

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

Chaves de ligação

Configura o acesso ao recurso alvo usando strings de ligação e chaves de acesso.

Depois de completares estes passos, continua para a secção seguinte para poderes criar o teu código.

2: Escreve o teu código

Na janela do Explorador, expanda a pasta do projeto da função e abra o ficheiro <nome-da-função>.cs.

Este ficheiro contém código de exemplo e elementos específicos de código com valores que forneceu anteriormente.

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

Elemento de código	valor
Nome do espaço de nomes	`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 padrão Run que você pode usar para começar. Este método de exemplo Run demonstra algumas capacidades disponíveis com a funcionalidade de funções personalizadas, como passar diferentes entradas e saídas, incluindo tipos complexos de .NET.

O ficheiro <nome da função>.cs também inclui a interface ILogger que fornece suporte para registar eventos num recurso do Application Insights. Pode enviar informação de rastreio para o Application Insights e armazenar essa informação juntamente com a informação de rastreio dos 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);

    <...>

}

Substitui o código da função de exemplo pelo teu próprio e edita o método padrão Run para os teus cenários específicos. 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 original, assumindo que não há alterações.

3: Compilar e construir o seu código

Depois de terminares de escrever o teu código, compila-o para garantir que não existem erros de compilação. O seu projeto de .NET funções inclui automaticamente tarefas de compilação, que compilam e adicionam o seu código à pasta lib\custom no seu projeto Logic App, onde os fluxos de trabalho procuram funções personalizadas para executar. Dependendo da sua versão .NET, estas tarefas colocam os assemblies na pasta lib\custom\net472 ou lib\custom\net8.

Siga estes passos:

No Visual Studio Code, na Barra de Atividade, selecione Explorer.
Na janela Explorer , abra o menu de atalho para a pasta do projeto de funções e selecione Construir projeto de funções.

A tarefa de compilação corre para o projeto de funções. Se a sua compilação for bem-sucedida, a janela do Terminal mostra uma mensagem de compilação bem-sucedida.
Confirme se os seguintes itens existem em seu projeto de aplicativo lógico:
- No seu espaço de trabalho, expanda as seguintes pastas: <your-logic-app>>lib\custom>net472 ou net8, com base na versão .NET. Confirme que a subpasta chamada net472 ou net8 contém os ficheiros assembly (DLL) necessários para executar o seu código, incluindo um ficheiro chamado <nome de função>.dll.
- No seu espaço de trabalho, expanda as seguintes pastas: <sua lógica app>>lib\custom><nome-da-função>. 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 aplicação lógica:

4: Chamar o seu código de um fluxo de trabalho

Depois de confirmares que o teu código compila e que o projeto da tua aplicação lógica contém os ficheiros necessários para o teu código correr, configura o teu fluxo de trabalho para chamar o teu código.

Na janela do Explorador, expande< nome >, < nome da aplicação> lógica e depois <nome do> fluxo de trabalho.

Abra o menu de atalho para workflow.json, e selecione Abrir designer.

O designer do workflow abre e mostra o workflow predefinido com o seguinte gatilho e ações:

Funcionamento	Descrição
Trigger	O gatilho de pedido incorporado chamado When a HTTP request is received (quando um pedido HTTP é recebido).
Action	A ação incorporada chamada Chamar uma função local nesta aplicação lógica.
Action	A ação de Resposta incorporada chamada Resposta que você usa para responder ao chamador apenas quando usa o gatilho Pedido.

No designer, selecione a ação chamada Chamar uma função local nesta aplicação lógica.

O painel de informação da ação abre-se para que possas configurar a chamada de função personalizada, por exemplo:
Revise e confirme se o valor do parâmetro Function Name está definido para a função que pretende executar. Revise ou altere quaisquer outros valores de parâmetro usados pela sua função.

5: Depurar o seu código e fluxo de trabalho

Para cada um dos seguintes serviços Armazenamento do Azure, inicie o emulador de armazenamento Azurite:
- Azure Blob Service
- Azure Queue Service
- Azure Table Service
1. No menu Visual Studio Code View, selecione Command Palette.
2. No aviso que aparece, selecione Azurite: Iniciar Serviço de Blob da lista.
3. Na lista de diretórios de trabalho que aparece, selecione a sua aplicação lógica.
4. Repita estas etapas para Azurite: Start Queue Service e Azurite: Start Table Service.
Se tiveres sucesso, a barra de tarefas do Visual Studio Code na parte inferior do ecrã mostra os três serviços de armazenamento a funcionar.
Anexe o depurador tanto ao seu projeto de aplicação lógica como ao projeto de funções .NET seguindo estes passos:
1. No Visual Studio Code, na Barra de Atividade, selecione Run and Debug (teclado: Ctrl+Shift+D).
2. Da lista Executar e Depurar, selecione Executar/Depurar a aplicação lógica com função local (<a sua aplicação lógica>) e depois selecione Play (ícone de seta verde).
  
  Ocorrem os seguintes eventos:
  - A janela Terminal é aberta e mostra o processo de depuração iniciado.
  - A janela da Consola de Depuração está aberta e mostra o estado da depuração.
  - No final do Visual Studio Code, a barra de tarefas fica laranja, indicando que o depurador .NET está carregado.
Para definir quaisquer pontos de interrupção, na definição da sua<função (> da função.cs) ou definição do fluxo de trabalho (workflow.json), encontre o número da linha onde quer o ponto de interrupção e selecione a coluna adjacente, por exemplo:
Para executar manualmente o gatilho de Pedido no seu fluxo de trabalho, abra a página de Visão Geral do fluxo:
1. A partir do teu projeto da Aplicação Lógica, abre o menu de contexto do ficheiro workflow.json, e depois seleciona Visão Geral.
  
  Na página Visão geral do fluxo de trabalho, o botão Acionar está disponível para quando se deseja iniciar manualmente o fluxo de trabalho. Em Propriedades do Fluxo de Trabalho, o valor da URL de Callback é a URL de um ponto de extremidade invocável criado pelo ativador de Solicitação no 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.
2. 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.
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.

A captura de tela mostra o Visual Studio Code e a execução concluída do fluxo de trabalho.

6: Implemente o seu código

Implementa as tuas funções personalizadas da mesma forma que implementas o teu projeto de Logic App. Quer implementes a partir do Visual Studio Code ou uses um processo DevOps CI/CD, certifica-te de que compilas o teu código antes de o implementares. Além disso, certifique-se de que todos os assemblies dependentes existem na seguinte pasta de projeto da Logic App antes de implementar:

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

Para mais informações, consulte Deploy Standard workflows from Visual Studio Code to 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:

Neste cenário, verifica o teu projeto de Logic App para ver se a pasta LogicApp\lib\custom está vazia. Se estiver vazio, no menu Terminal, selecione Executar Tarefa>construir Funções.

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

Se receberes esta mensagem de erro ao executar o teu fluxo de trabalho, provavelmente associaste o processo de depuração às Funções .NET, em vez de à tua aplicação lógica.

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 de Saída mostrar um erro semelhante à mensagem seguinte, 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)

Criar fluxos de trabalho de aplicações de lógica padrão com Visual Studio Code

Comentários

Esta página foi útil?

Last updated on 2026-04-08