Partager via

Ajouter et exécuter des scripts C# inline avec des flux de travail Standard pour Azure Logic Apps (préversion)

  • Article

S’applique à : Azure Logic Apps (Standard)

Remarque

Cette fonctionnalité est en préversion et est soumise aux conditions d’utilisation supplémentaires des préversions de Microsoft Azure.

Pour effectuer des tâches d’intégration personnalisées en ligne avec votre flux de travail Standard dans Azure Logic Apps, vous pouvez ajouter et exécuter directement des scripts C# à partir de votre flux de travail. Pour cette tâche, utilisez l’action Code Inline nommée Exécuter le code de script CSharp. Cette action retourne les résultats de votre script afin de vous permettre d’utiliser cette sortie dans les actions suivantes de votre flux de travail.

Cette fonctionnalité offre les avantages suivants :

  • Écrivez vos propres scripts dans le Concepteur de flux de travail afin de pouvoir résoudre des problèmes d’intégration plus complexes sans avoir à utiliser Azure Functions. Aucun autre plan de service n’est nécessaire.

    Cet avantage simplifie le développement de flux de travail et réduit la complexité et le coût de la gestion d’un plus grand nombre de services.

  • Générez un fichier de code dédié, qui fournit un espace de script personnalisé dans votre flux de travail.

  • Déployez des scripts en même temps que vos flux de travail.

Ce guide montre comment ajouter l’action dans votre flux de travail et ajouter le code de script C# que vous souhaitez exécuter.

Prérequis

  • Un compte et un abonnement Azure. Si vous n’avez pas encore d’abonnement, vous pouvez vous inscrire pour obtenir un compte Azure gratuitement.

  • Flux de travail d’application logique standard dans lequel vous souhaitez ajouter votre script C#. Le workflow doit déjà commencer par un déclencheur. Pour plus d’informations, consultez Créer des exemples de flux de travail d’application logique standard.

    Vous pouvez utiliser n’importe quel déclencheur pour votre scénario, mais, par exemple, ce guide utilise le déclencheur de Requête nommé Lorsqu’une requête HTTP est reçue et également l’action Réponse. Le flux de travail s’exécute lorsqu’une autre application ou flux de travail envoie une requête à l’URL du point de terminaison du déclencheur. L’exemple de script retourne les résultats de l’exécution du code en tant que sortie que vous pouvez utiliser dans les actions suivantes.

Exemples de scénarios

La liste suivante décrit certains exemples de scénarios dans lesquels vous pouvez utiliser un script vous aide à effectuer certaines tâches d’intégration :

  • Analysez et effectuez des transformations ou des manipulations sur une charge utile au-delà des fonctionnalités intégrées des expressions et des opérations de données. Par exemple, vous pouvez utiliser un script pour retourner un schéma modifié pour le traitement en aval.

  • Gérez des ressources Azure telles que des machines virtuelles et démarrez-les ou effectuez des étapes en fonction d’une logique métier.

  • Exécutez une procédure stockée sur un serveur SQL qui doit s’exécuter selon une planification et stockez les résultats sur SharePoint.

  • Consignez les erreurs de flux de travail avec des informations détaillées en enregistrant dans Stockage Azure ou en envoyant un e-mail ou en informant votre équipe.

  • Chiffrer et déchiffrer les données pour se conformer aux normes de sécurité des API.

  • Transmettez un fichier dans le script pour compresser ou décompresser une requête HTTP.

  • Agréger des données provenant de diverses API et fichiers pour créer des rapports quotidiens

À propos de l’installation

  • Le portail Azure enregistre votre script en tant que fichier de script C# (.csx) dans le même dossier que votre fichier workflow.json, qui stocke la définition JSON de votre flux de travail et déploie le fichier dans votre ressource d’application logique, ainsi que la définition de flux de travail. Azure Logic Apps compile ce fichier pour préparer le script à l’exécution.

    Le format de fichier .csx vous permet d’écrire moins de « code réutilisable » et de vous concentrer sur l’écriture d’une fonction C#. Vous pouvez renommer le fichier .csx pour faciliter la gestion pendant le déploiement. Toutefois, chaque fois que vous renommez le script, la nouvelle version remplace la version précédente.

  • Le script est local dans le flux de travail. Pour utiliser le même script dans d’autres flux de travail, afficher le fichier de script dans la console KuduPlus, puis copier le script pour le réutiliser dans d’autres flux de travail.

Limites

Nom Limite Remarques
Durée de l’exécution du script 10 minutes Si vous avez des scénarios qui nécessitent des durées plus longues, utilisez l’option de commentaires sur le produit pour fournir plus d’informations sur vos besoins.
Taille de sortie 100 Mo La taille de sortie dépend de la limite de taille de sortie pour les actions, qui est généralement de 100 Mo.

Ajouter l’action Exécuter le code de script CSharp

  1. Sur le portail Azure, ouvrez votre application logique Standard et votre flux de travail dans le concepteur.

  2. Dans le concepteur, suivez ces étapes générales pour ajouter l’action Opérations de code inline appelée Exécuter le code de script CSharp à votre flux de travail.

  3. Une fois le volet d’informations d’action ouvert, sous l’onglet Paramètres, dans la zone Fichier de code, mettez à jour l’exemple de code prépoplué avec votre propre code de script.

    L’exemple suivant montre l’onglet Paramètres de l’action avec l’exemple de code de script :

    Capture d’écran montrant le portail Azure, le concepteur de flux de travail Standard, le déclencheur de requête, l’action Exécuter le code de script CSharp avec le volet d’informations ouvert et l’action Réponse. Le volet d’informations affiche l’exemple de script C#.

    L’exemple suivant montre l’exemple de code de script :

    /// Add the required libraries.
#r "Newtonsoft.Json"
#r "Microsoft.Azure.Workflows.Scripting"
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Microsoft.Extensions.Logging;
using Microsoft.Azure.Workflows.Scripting;
using Newtonsoft.Json.Linq;

/// <summary>
/// Executes the inline C# code.
/// </summary>
/// <param name="context">The workflow context.</param>
/// <remarks> The entry-point to your code. The function signature should remain unchanged.</remarks>
public static async Task<Results> Run(WorkflowContext context, ILogger log)
{
    var triggerOutputs = (await context.GetTriggerResults().ConfigureAwait(false)).Outputs;

    /// Dereferences the 'name' property from the trigger payload.
    var name = triggerOutputs?["body"]?["name"]?.ToString();

    /// To get the outputs from a preceding action, you can uncomment and repurpose the following code.
    // var actionOutputs = (await context.GetActionResults("<action-name>").ConfigureAwait(false)).Outputs;

    /// The following logs appear in the Application Insights traces table.
    // log.LogInformation("Outputting results.");
    // var name = null;

    return new Results
    {
        Message = !string.IsNullOrEmpty(name) ? $"Hello {name} from CSharp action" : "Hello from CSharp action."
    };
}

public class Results
{
    public string Message {get; set;}
}

    Pour plus d’informations, consultez « #r » - Référencer des assemblys externes.

  4. Lorsque vous avez terminé, enregistrez votre flux de travail.

Après avoir exécuté votre flux de travail, vous pouvez passer en revue la sortie du flux de travail dans Application Insights, s’il est activé. Pour plus d’informations, consultez Afficher les journaux dans Application Insights.

Importer des espaces de noms

Pour importer des espaces de noms, procédez ainsi avec la clause using comme d’habitude. La liste suivante inclut des espaces de noms importés automatiquement. Vous pouvez donc les inclure dans votre script :

System
System.Collections.Generic
System.IO
System.Linq
System.Net.Http
System.Threading.Tasks
Microsoft.Azure.WebJobs
Microsoft.Azure.WebJobs.Host

Ajouter des références à des assemblys externes

Pour référencer des assemblys .NET Framework, utilisez la directive #r "<assembly-name>, par exemple :

/// Add the required libraries.
#r "Newtonsoft.Json"
#r "Microsoft.Azure.Workflows.Scripting"
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Microsoft.Extensions.Logging;
using Microsoft.Azure.Workflows.Scripting;
using Newtonsoft.Json.Linq;

public static async Task<Results> Run(WorkflowContext context)
{
    <...>
}

public class Results
{
    <...>
}

La liste suivante inclut les assemblys automatiquement ajoutés par l’environnement d’hébergement Azure Functions :

mscorlib
System
System.Core
System.Xml
System.Net.Http
Microsoft.Azure.WebJobs
Microsoft.Azure.WebJobs.Host
Microsoft.Azure.WebJobs.Extensions
System.Web.Http
System.Net.Http.Formatting
Newtonsoft.Json

Sortie du journal vers un flux

Dans votre méthode Run, incluez un paramètre avec type ILogger et log comme nom, par exemple :

public static void Run(WorkflowContext context, ILogger log)
{
    log.LogInformation($"C# script successfully executed.");
}

Sortie de journal vers Application Insights

Pour créer des métriques personnalisées dans Application Insights, utilisez la méthode d’extension LogMetric sur ILogger.

L’exemple suivant montre un exemple d’appel de méthode :

logger.LogMetric("TestMetric", 1234);

Accéder aux sorties de déclencheur et d’action de flux de travail dans votre script

Pour accéder aux données à partir de votre flux de travail, utilisez les méthodes suivantes disponibles pour l’objet de contexte WorkflowContext :

  • Méthode GetTriggerResults

    Pour accéder aux sorties du déclencheur, utilisez cette méthode pour renvoyer un objet qui représente le déclencheur et ses sorties, qui sont disponibles via la propriété Outputs. Cet objet a le type JObject, et vous pouvez utiliser les crochets ([]) comme indexeur pour accéder à diverses propriétés dans les sorties du déclencheur.

    L’exemple suivant obtient les données de la propriété body dans les sorties du déclencheur :

    public static async Task<Results> Run(WorkflowContext context, ILogger log)
{

    var triggerOutputs = (await context.GetTriggerResults().ConfigureAwait(false)).Outputs;
    var body = triggerOutputs["body"];

    return new Results;

}

public class Results
{
    <...>
}

  • Méthode GetActionResults

    Pour accéder aux sorties d’action, utilisez cette méthode pour renvoyer un objet qui représente l’action et ses sorties, qui sont disponibles via la propriété Outputs. Cette méthode accepte un nom d’action comme paramètre. L’exemple suivant obtient les données de la propriété body dans les sorties d’une action appelée nom-action :

    public static async Task<Results> Run(WorkflowContext context, ILogger log)
{

    var actionOutputs = (await context.GetActionResults("action-name").ConfigureAwait(false)).Outputs;
    var body = actionOutputs["body"];

    return new Results;

}

public class Results
{
    <...>
}

Accéder aux variables d’environnement ou à la valeur du paramètre d’application

Pour obtenir une variable d’environnement ou une valeur de paramètre d’application, utilisez la méthode System.Environment.GetEnvironmentVariable, par exemple :

public static void Run(WorkflowContext context, ILogger log)
{
    log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
    log.LogInformation(GetEnvironmentVariable("AzureWebJobsStorage"));
    log.LogInformation(GetEnvironmentVariable("WEBSITE_SITE_NAME"));
}

public static string GetEnvironmentVariable(string name)
{
    return name + ": " +
    System.Environment.GetEnvironmentVariable(name, EnvironmentVariableTarget.Process);
}

Retourner des données à votre flux de travail

Pour cette tâche, implémentez votre méthode Run avec un type de retour et une instruction return. Si vous souhaitez une version asynchrone, implémentez la méthode Run avec un attribut Task<return-type> et le mot clé async. La valeur de retour est définie dans la propriété body des sorties de l’action de script, que toutes les actions de flux de travail suivantes peuvent ensuite référencer.

L’exemple suivant montre une méthode Run avec un attribut Task<Results>, le mot clé async et une instruction return :

public static async Task<Results> Run(WorkflowContext context, ILogger log)
{
    return new Results
    {
        Message = !string.IsNullOrEmpty(name) ? $"Returning results with status message."
    };
}

public class Results
{
    public string Message {get; set;}
}

Afficher le fichier de script

  1. Dans le portail Azure, ouvrez votre ressource d’application logique Standard avec le flux de travail souhaité.

  2. Dans le menu des ressources de l’application logique, sous Outils de développement, sélectionnez Outils Avancés.

  3. Dans la page Outils avancés, sélectionnez Go, qui ouvre la console KuduPlus.

  4. Ouvrez le menu de la console de débogage, puis sélectionnez CMD.

  5. Accédez à l’emplacement racine de votre application logique : site/wwwroot

  6. Accédez au dossier de votre workflow, qui contient le fichier .csx, le long de ce chemin : site/wwwroot/{workflow-name}

  7. En regard du nom de fichier, sélectionnez Modifier pour ouvrir et afficher le fichier.

Afficher les journaux d’activité dans Application Insights

  1. Dans le portail Azure, dans le menu de ressources de l’application logique, sous Paramètres, sélectionnez Application Insights, puis votre application logique.

  2. Dans le menu Application Insights, sous Surveillance, sélectionnez Journaux.

  3. Créez une requête pour rechercher des traces ou des erreurs dans l’exécution de votre flux de travail, par exemple :

    union traces, errors
| project TIMESTAMP, message

Erreurs de compilation

Dans cette version, l’éditeur web inclut une prise en charge limitée d’IntelliSense, qui est toujours en cours d’amélioration. Toutes les erreurs de compilation sont détectées lorsque vous enregistrez votre flux de travail et que le runtime Azure Logic Apps compile votre script. Ces erreurs apparaissent dans les journaux d’erreurs de votre application logique.

Erreurs d’exécution

Si une erreur se produit lorsque votre script s’exécute, Azure Logic Apps effectue les étapes suivantes :

  • Transmet l’erreur à votre flux de travail.
  • Marque l’action de script comme Échec.
  • Fournit un objet d’erreur qui représente l’exception levée à partir de votre script.

L’exemple suivant illustre un exemple d’erreur :

La fonction « CSharp_MyLogicApp-InvalidAction_execute_csharp_script_code.csx » a échoué avec l’erreur « L’action "inexistante" n’existe pas dans le flux de travail. » lors de l’exécution. Vérifiez que le code de fonction est valide.

Exemples de scripts

Les exemples de scripts suivants effectuent différentes tâches que vous pouvez effectuer

Décompresser un fichier ZIP avec des fichiers texte d’une action HTTP dans un tableau de chaînes

// Add the required libraries.
#r "Newtonsoft.Json"
#r "Microsoft.Azure.Workflows.Scripting"
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Microsoft.Azure.Workflows.Scripting;
using System;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Collections.Generic;

/// <summary>
/// Executes the inline C# code.
/// </summary>
/// <param name="context">The workflow context.</param>
public static async Task<List<string>> Run(WorkflowContext context)
{

    var outputs = (await context.GetActionResults("HTTP_1").ConfigureAwait(false)).Outputs;
    var base64zipFileContent = outputs["body"]["$content"].ToString();

    // Decode base64 to bytes.
    byte[] zipBytes = Convert.FromBase64String(base64zipFileContent);

    List<string> fileContents = new List<string>();

    // Creates an in-memory stream from the zip bytes.
    using (MemoryStream zipStream = new MemoryStream(zipBytes))
    {

        // Extracts files from the zip archive.
        using (ZipArchive zipArchive = new ZipArchive(zipStream))
        {

            foreach (ZipArchiveEntry entry in zipArchive.Entries)
            {

                // Read each file's content.
                using (StreamReader reader = new StreamReader(entry.Open()))
                {
                    string fileContent = reader.ReadToEnd();
                    fileContents.Add(fileContent);
                }
            }
        }
    }

    return fileContents;
}

Chiffrer des données à l’aide d’une clé à partir des paramètres de l’application

// Add the required libraries.
#r "Newtonsoft.Json"
#r "Microsoft.Azure.Workflows.Scripting"
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Microsoft.Azure.Workflows.Scripting;
using Newtonsoft.Json.Linq;
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

/// <summary>
/// Executes the inline csharp code.
/// </summary>
/// <param name="context">The workflow context.</param>
public static async Task<string> Run(WorkflowContext context)
{

    var compose = (await context.GetActionResults("compose").ConfigureAwait(false)).Outputs;
    var text = compose["sampleData"].ToString();

    return EncryptString(text);

}

public static string EncryptString(string plainText)
{

    var key = Environment.GetEnvironmentVariable("app-setting-key");
    var iv = Environment.GetEnvironmentVariable("app-setting-iv");

    using (Aes aesAlg = Aes.Create())
    {

        aesAlg.Key = Encoding.UTF8.GetBytes(key);
        aesAlg.IV = Encoding.UTF8.GetBytes(iv);
        ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

        using (MemoryStream msEncrypt = new MemoryStream())
        {

            using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
            {

                using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                {
                    swEncrypt.Write(plainText);
                }

            }

             return Convert.ToBase64String(msEncrypt.ToArray());

        }
    }
}

Classe WorkflowContext

Représente un contexte de flux de travail.

Méthodes

GetActionResult(string actionName)

Obtient le résultat d’une action spécifique dans le flux de travail.

La version asynchrone utilise Tâche<> comme type de retour, par exemple :

Task<WorkflowOperationResult> GetActionResult(string actionName)

Paramètres

actionName: nom de l’action.

Retours

La version asynchrone retourne un objet Task qui représente l’opération asynchrone. Le résultat de la tâche contient un objet WorkflowOperationResult. Pour plus d’informations sur les propriétés de l’objet WorkflowOperationResult, consultez classe WorkflowOperationResult.

RunTriggerResult()

Obtient le résultat du déclencheur dans le flux de travail.

La version asynchrone utilise Tâche<> comme type de retour, par exemple :

Task<WorkflowOperationResult> RunTriggerResult()

Paramètres

Aucune.

Retours

La version asynchrone retourne un objet Task qui représente l’opération asynchrone. Le résultat de la tâche contient un objet WorkflowOperationResult. Pour plus d’informations sur les propriétés de l’objet WorkflowOperationResult, consultez classe WorkflowOperationResult.

Classe WorkflowOperationResult

Représente le résultat d’une opération de flux de travail.

Propriétés

Nom Type Description
Nom Chaîne Obtient ou définit le nom de l’opération.
Entrées JToken Obtient ou définit les entrées d’exécution de l’opération.
Sorties JToken Obtient ou définit les sorties d’exécution de l’opération.
StartTime DateTime? Obtient ou définit l’heure de début de l’opération.
EndTime DateTime? Obtient ou définit l’heure de fin de l’opération.
OperationTrackingId Chaîne Obtient ou définit l’ID de suivi des opérations.
Code Chaîne Obtient ou définit le code d’état de l’action.
État Chaîne Obtient ou définit l’état de l’action.
Error JToken Obtient ou définit l’erreur pour l’action.
TrackedProperties JToken Obtient ou définit les propriétés suivies pour l’action.

Contenu connexe

Ajouter et exécuter des extraits de code JavaScript