Creación y ejecución de código .NET desde flujos de trabajo estándar en Azure Logic Apps mediante Visual Studio Code

Se aplica a: Azure Logic Apps (Estándar)

Cuando el escenario de integración necesita tareas personalizadas o lógica más allá de las operaciones y conectores integrados en Azure Logic Apps, cree y ejecute código .NET como funciones personalizadas en sus flujos de trabajo estándar. Después, el flujo de trabajo puede realizar tareas como el análisis personalizado, la validación o incluso aplicar reglas de negocios. Con esta funcionalidad, puede implementar escenarios como las siguientes tareas:

Personalización de la implementación de lógica de negocios.
Personalice el análisis para extraer información de un mensaje entrante.
Realice la validación de datos y las transformaciones simples.
Realice cálculos.
Dar forma a los mensajes salientes enviados a otro sistema, como una API.

En esta guía se muestra cómo escribir y ejecutar su propio código .NET directamente en flujos de trabajo estándar mediante Visual Studio Code. Aprenderá a crear, depurar e implementar funciones locales mediante Visual Studio Code para que pueda mantener juntos el código personalizado y la orquestación del flujo de trabajo, depurarlos en una sola sesión e implementarlos como una única solución.

Nota:

El código .NET insertado personalizado no es adecuado para los escenarios siguientes:

Ejecución de procesos que pueden superar los 10 minutos.
Aplicar transformaciones a mensajes y datos grandes.
Realizar operaciones complejas de agrupación o desagrupación.
Uso de componentes de canalización de BizTalk Server que implementan streaming.

Para obtener más información, consulta Limitaciones.

Requisitos previos

Una cuenta y una suscripción de Azure. Obtener una cuenta gratuita de Azure.
La versión más reciente de Visual Studio Code con la extensión de Azure Logic Apps (estándar).

Para conocer los requisitos previos, consulte Crear flujos de trabajo estándar en Azure Logic Apps de inquilino único con Visual Studio Code.

La extensión proporciona las siguientes funcionalidades y ventajas:
- Escriba su propio código mediante la creación de funciones que tengan la flexibilidad y el control para resolver los problemas de integración más difíciles.
- Depurar código localmente en Visual Studio Code. Recorra el código y los flujos de trabajo en la misma sesión de depuración.
- Implemente código junto con los flujos de trabajo. No es necesario ningún otro plan de servicio.
- Se pueden realizar procesos de migración de BizTalk Server para que pueda migrar mediante lift-and-shift inversiones personalizadas de .NET del entorno local a la nube.
Carpeta local que se va a usar para el proyecto de código.

Limitaciones

Solo puede usar la funcionalidad de funciones personalizadas en Visual Studio Code que se ejecuta en Windows. Esta funcionalidad admite el uso de .NET Framework y .NET 8 para flujos de trabajo de aplicaciones lógicas estándar implementados y hospedados en Azure.
No puede usar la creación de funciones personalizadas en Azure Portal. Sin embargo, para trabajar con salidas de funciones personalizadas en el flujo de trabajo, siga estos pasos:
1. Después de implementar sus funciones en Azure, siga los pasos descritos en Llamar a su código desde un flujo de trabajo en el portal de Azure.
2. Agregue la acción integrada denominada Llamar a una función local en esta aplicación lógica al flujo de trabajo. Seleccione las funciones personalizadas implementadas que desee y ejecute el código.
3. Utilice acciones posteriores del flujo de trabajo para hacer referencia a las salidas de funciones personalizadas, como puede hacerlo en cualquier otro flujo de trabajo. Puede ver el historial de ejecución, las entradas y las salidas de la acción integrada.

Para conocer las limitaciones generales, consulte Limits y referencia de configuración para Azure Logic Apps.

1: Creación de un proyecto de código

La extensión Azure Logic Apps (Estándar) para Visual Studio Code incluye una plantilla de proyecto de código que proporciona una experiencia simplificada para escribir, depurar e implementar su propio código con los flujos de trabajo. Esta plantilla de proyecto crea un archivo de área de trabajo y dos proyectos de ejemplo: un proyecto para escribir el código y otro proyecto para crear los flujos de trabajo.

Nota:

No puede usar la misma carpeta de proyecto para el código y los flujos de trabajo.

Para crear un proyecto de código, siga estos pasos:

En Visual Studio Code, inicia sesión en tu cuenta de Azure.

Si el inicio de sesión tarda más de lo habitual, Visual Studio Code le pedirá que inicie sesión a través de un sitio web de autenticación de Microsoft proporcionándole un código de dispositivo. Para iniciar sesión con el código en su lugar, siga estos pasos:
1. Seleccione Usar código de dispositivo y, a continuación, seleccione Copiar y abrir.
2. Seleccione Abrir vínculo para abrir una nueva ventana del explorador y continuar con el sitio web de autenticación.
3. En la página Iniciar sesión en tu cuenta, escriba el código de autenticación y seleccione Siguiente.
En la barra de actividades, seleccione el icono de Azure.
En la ventana Azure, vaya a la sección Workspace. Mueva el puntero sobre el área de título para que aparezca la barra de herramientas.
En el menú Azure Logic Apps, seleccione Crear área de trabajo de aplicación lógica nueva.
En la ventana Seleccionar carpeta, vaya a la carpeta del proyecto local, seleccione la carpeta y, a continuación, Seleccione.
En la ventana Crear área de trabajo de la aplicación lógica, en el indicador Nombre del área de trabajo, escriba un nombre para el área de trabajo y pulse Entrar.

En este ejemplo se usa weather-app como nombre del área de trabajo:

En este ejemplo se usa weather-project como nombre del área de trabajo.
Para seleccionar una plantilla para su nuevo proyecto, seleccione aplicación de lógica con proyecto de código personalizado.
En la solicitud Seleccionar un marco de destino, seleccione .NET Framework o .NET 8.

Siga las indicaciones siguientes para proporcionar la siguiente información:

Pronto	Valor de ejemplo
Nombre de la aplicación lógica	`weather-logic-app`
nombre de función para el proyecto de funciones de .NET	`WeatherForecast`
Namespace para el proyecto de funciones de .NET	`Contoso.Enterprise`
Seleccione una plantilla para el primer flujo de trabajo del proyecto: - Flujo de trabajo con estado - Flujo de trabajo sin estado - Agente autónomo - Agente conversacional - Omitir por ahora	Flujo de trabajo con estado
Nombre del flujo de trabajo	`weather-workflow`

Para el indicador Seleccionar cómo desea abrir su proyecto, seleccione Abrir en la ventana actual.

Después de finalizar este paso, Visual Studio Code crea el área de trabajo, que incluye un proyecto de funciones de .NET y un proyecto de aplicación lógica, por ejemplo:

La captura de pantalla muestra el área de trabajo creada con el proyecto de aplicación lógica y el proyecto de funciones .NET.

En la ventana Explorador , tenga en cuenta las siguientes carpetas del área de trabajo:

Carpeta	Descripción
< workspace-name>	Contiene tanto el proyecto de funciones de .NET como el proyecto de flujo de trabajo de la aplicación lógica.
< Nombre de la aplicación lógica>	Contiene los archivos y otros artefactos del proyecto de aplicación lógica. Por ejemplo, el archivo workflow.json es el archivo de definición de flujo de trabajo donde puede compilar el flujo de trabajo.
< nombre de función>	Contiene los archivos y otros artefactos del proyecto de funciones de .NET. Por ejemplo, el archivo <function-name>.cs es el archivo de código donde puede crear el código.

Para la indicación Habilitar conectores para Azure en Logic Apps <logic-app-name>, seleccione Usar conectores de Azure.
En el mensaje Seleccionar suscripción, seleccione la suscripción de Azure que desee.
Para el mensaje de Seleccionar un grupo de recursos para nuevos recursos, seleccione el grupo de recursos que desee o Crear nuevo grupo de recursos.
En el recuadro Seleccionar una ubicación para los nuevos recursos, elija la región Azure para la implementación.

En el Seleccionar método de autenticación para conectores Azure, seleccione el tipo de autenticación que se usará para las conexiones que necesitan autenticación.

Tipo de autenticación	Descripción
Identidad administrada	Seleccione Managed Service Identity para usar la identidad asignada por el sistema o asignada por el usuario en el recurso de la aplicación lógica. De forma predeterminada, los recursos de aplicación lógica estándar ya tienen habilitada la identidad asignada por el sistema. Aun así, debe configurar la identidad con acceso mediante roles en el recurso de destino, además de cualquier otro requisito. Para obtener más información, consulte Asignación de acceso basado en roles a una identidad administrada.
Claves de conexión	Configure el acceso al recurso de destino mediante cadenas de conexiones y claves de acceso.

Tipo de autenticación

Descripción

Identidad administrada

Seleccione Managed Service Identity para usar la identidad asignada por el sistema o asignada por el usuario en el recurso de la aplicación lógica.

De forma predeterminada, los recursos de aplicación lógica estándar ya tienen habilitada la identidad asignada por el sistema. Aun así, debe configurar la identidad con acceso mediante roles en el recurso de destino, además de cualquier otro requisito.

Para obtener más información, consulte Asignación de acceso basado en roles a una identidad administrada.

Claves de conexión

Configure el acceso al recurso de destino mediante cadenas de conexiones y claves de acceso.

Después de completar estos pasos, continúe con la sección siguiente para que pueda crear el código.

2: Escribir el código

En la ventana Explorador, expanda la carpeta del proyecto de función y abra el < archivo function-name>.cs.

Este archivo contiene código de ejemplo y elementos de código específicos con los valores proporcionados anteriormente.

En este ejemplo, el archivo de función WeatherForecast.cs contiene estos elementos de código con valores de ejemplo:

Elemento de Código	Importancia
Nombre del espacio de nombres	`Contoso.Enterprise`
Nombre de clase	`WeatherForecast`
Nombre de función	`WeatherForecast`
Parámetros de función	`zipcode`, `temperatureScale`
Tipo de valor devuelto	`Task`
Tipo complejo	`Weather`

A continuación se muestra un ejemplo de código de ejemplo 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; }
        }
    }
}

La definición de función incluye un método predeterminado Run que puede usar para empezar. En este ejemplo Run método se muestran algunas funcionalidades disponibles con la característica de funciones personalizadas, como pasar entradas y salidas diferentes, incluidos tipos de .NET complejos.

El < archivo function-name>.cs también incluye la interfaz que proporciona soporte para el ILogger registro de eventos en un recurso de Application Insights. Puede enviar información de seguimiento a Application Insights y almacenar esa información con la información de seguimiento de los flujos de trabajo, por ejemplo:

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

    <...>

}

Reemplace el código de función de ejemplo por el suyo propio y edite el método predeterminado Run para sus escenarios específicos. O bien, puede copiar la función, incluida la declaración [FunctionName("<function-name>")] y, a continuación, cambiar el nombre de la función por un nombre único. Puede editar la función que se volvió a nombrar para satisfacer sus necesidades.

Este ejemplo continúa con el código de ejemplo original, suponiendo que no haya cambios.

3: Compilar y construir el código

Después de terminar de escribir el código, compile para asegurarse de que no existen errores de compilación. El proyecto de funciones de .NET incluye automáticamente tareas de compilación, que compilan y agregan el código a la carpeta lib\custom en el proyecto de aplicación lógica donde los flujos de trabajo buscan funciones personalizadas para ejecutarse. En función de la versión de .NET, estas tareas colocan los ensamblados en la carpeta lib\custom\net472 o lib\custom\net8.

Siga estos pasos:

En Visual Studio Code, en la barra de actividades, seleccione Explorer.
En la ventana Explorador , abra el menú contextual de la carpeta del proyecto de functions y seleccione Compilar proyecto de funciones.

La tarea de compilación se ejecuta para el proyecto de funciones. Si la compilación se realiza correctamente, la ventana Terminal muestra un mensaje Compilación correcta .
Confirme que existen los siguientes elementos en el proyecto de aplicación lógica:
- En el área de trabajo, expanda las siguientes carpetas: <your-logic-app>>lib\custom>net472 o net8, en función de la versión de .NET. Confirme que la subcarpeta denominada net472 o net8 contiene los archivos de ensamblado (DLL) necesarios para ejecutar el código, incluido un archivo denominado nombre<de> función.dll.
- En el área de trabajo, expande las siguientes carpetas: <tu aplicación lógica>>lib\custom><function-name>. Confirme que la subcarpeta denominada <nombre-de-la-función> contiene un archivo función.json, que incluye los metadatos sobre el código de función que escribió. El diseñador de flujo de trabajo usa este archivo para determinar las entradas y salidas necesarias al llamar al código.
En el ejemplo siguiente se muestran ensamblados generados de ejemplo y otros archivos en el proyecto de aplicación lógica:

4: Llamar al código a través del flujo de trabajo

Después de confirmar que el código se compila y el proyecto de aplicación lógica contiene los archivos necesarios para que se ejecute el código, configure el flujo de trabajo para llamar al código.

En la ventana Explorador, expanda <workspace-name>, <logic-app-name> y, a continuación<, workflow-name>.

Abra el menú contextual de workflow.jsony seleccione Abrir diseñador.

El diseñador de flujo de trabajo se abre y muestra el flujo de trabajo predeterminado con el siguiente desencadenador y acciones:

Operación	Descripción
Trigger	Desencadenador de solicitud integrado denominado Cuando se recibe una solicitud HTTP.
Acción	La acción integrada denominada Llamar a una función local en esta aplicación lógica.
Acción	La acción de respuesta integrada denominada Respuesta se utiliza para responder a la persona que llama solo cuando se emplea el desencadenador Petición.

En el diseñador, seleccione la acción llamada Llamar a una función local en esta aplicación lógica.

Se abre el panel de información de la acción para que pueda configurar la llamada de función personalizada, por ejemplo:
Revise y confirme que el valor del parámetro Nombre de función está establecido en la función que desea ejecutar. Revise o cambie cualquier otro valor de parámetro que use la función.

5: Depurar el código y el flujo de trabajo

Para cada uno de los siguientes servicios de Azure Storage, inicie el emulador de almacenamiento de Azurite:
- Azure Blob Service
- Azure Queue Service
- Azure Table Service (Servicio de Tabla de Azure)
1. En el menú Visual Studio Code View, seleccione Paleta de comandos.
2. En el mensaje que aparece, seleccione Azurite: Start Blob Service en la lista.
3. En la lista de directorios de trabajo que aparece, seleccione la aplicación lógica.
4. Repita estos pasos para Azurite: Iniciar Queue Service y Azurite: Iniciar Table Service.
Si se ejecuta correctamente, la barra de tareas Visual Studio Code en la parte inferior de la pantalla muestra los tres servicios de almacenamiento en ejecución.
Adjunte el depurador tanto al proyecto de aplicación lógica como al proyecto de funciones de .NET siguiendo estos pasos:
1. En Visual Studio Code, en la barra de actividades, seleccione Run and Debug (teclado: Ctrl+Mayús+D).
2. En la lista Ejecutar y depurar, seleccione Ejecutar/Depurar aplicación lógica con función local (<su aplicación lógica>) y, a continuación, seleccione Ejecutar (flecha verde).
  
  Se producen los siguientes eventos:
  - Se abre la ventana Terminal y se muestra el proceso de depuración iniciado.
  - Se abre la ventana Consola de depuración y se muestra el estado de depuración.
  - En la parte inferior de Visual Studio Code, la barra de tareas se vuelve naranja, lo que indica que se carga el depurador .NET.
Para establecer los puntos de interrupción, en la definición de función (<nombre> de función.cs) o definición de flujo de trabajo (workflow.json), busque el número de línea donde desee el punto de interrupción y seleccione la columna adyacente, por ejemplo:
Para ejecutar manualmente el desencadenador de Solicitud en su flujo de trabajo, abra la página de Resumen del flujo de trabajo:
1. En el proyecto de aplicación lógica, abra el menú contextual del archivoworkflow.json y, a continuación, seleccione Información general.
  
  En la página Información general del flujo de trabajo, el botón Ejecutar desencadenador está disponible para cuando desee iniciar manualmente el flujo de trabajo. En Propiedades del flujo de trabajo, el valor de Dirección URL de devolución de llamada es la dirección URL de un punto de conexión al que se puede llamar creado por el desencadenador Solicitud en el flujo de trabajo. Puede enviar solicitudes a esta dirección URL para desencadenar el flujo de trabajo desde otras aplicaciones, incluidos otros flujos de trabajo de aplicaciones lógicas.
2. En la barra de herramientas de la página Información general, seleccione Ejecutar desencadenador.
  
  Una vez que el flujo de trabajo comienza a ejecutarse, el depurador activa el primer punto de interrupción.
3. En el menú Ejecutar o en la barra de herramientas del depurador, seleccione una acción de depuración.
Una vez completada la ejecución del flujo de trabajo, la página Información general muestra la ejecución finalizada y los detalles básicos sobre esa ejecución.
Para revisar más información sobre la ejecución del flujo de trabajo, seleccione la ejecución finalizada. O bien, en la lista situada junto a la columna Duración, seleccione Mostrar ejecución.

6: Implementación del código

Implemente las funciones personalizadas de la misma manera que implemente el proyecto de aplicación lógica. Tanto si implementa desde Visual Studio Code como si usa un proceso de CI/CD DevOps, asegúrese de compilar el código antes de implementarlo. Además, asegúrese de que todos los ensamblados dependientes existan en la siguiente carpeta de proyecto de aplicación lógica antes de implementar:

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

Para obtener más información, consulte Deploy Standard workflows from Visual Studio Code to Azure.

Solucionar problemas

Error del panel de información de acción

En el diseñador de flujos de trabajo, al seleccionar la acción integrada denominada Llamar a una función local en esta aplicación lógica, el panel de información de la acción muestra el mensaje siguiente:

Failed to retrieve dynamic inputs. Error details:

En este escenario, compruebe el proyecto de aplicación lógica para ver si la carpeta LogicApp\lib\custom está vacía. Si está vacío, en el menú Terminal, seleccione Ejecutar tarea> funciones de compilación.

Actualmente no se está ejecutando ningún proceso con el nombre especificado.

Si recibe este mensaje de error al ejecutar el flujo de trabajo, es probable que asocie el proceso del depurador a .NET Functions, en lugar de a la aplicación lógica.

Para solucionar este problema, en la lista Ejecutar y depurar, seleccione Asociar a la aplicación lógica (LogicApp) y, a continuación, seleccione Reproducir (flecha verde).

Paquete no importado correctamente

Si la ventana Salida muestra un error similar al siguiente mensaje, asegúrese de que tiene al menos .NET 6.0 instalado. Si tiene instalada esta versión, intente desinstalarla y volver a instalarla.

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]

Errores de compilación

Si la función no incluye variables y usted compila el código, la ventana Salida podría mostrar los siguientes mensajes de error:

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 solucionar este problema, en el método Run del código, anexe el parámetro siguiente:

string parameter1 = null

En el ejemplo siguiente se muestra cómo aparece la firma del método Run:

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

Crear flujos de trabajo de aplicaciones lógicas estándar con Visual Studio Code

Comentarios

¿Le resultó útil esta página?

Last updated on 2026-04-08