Ajouter des boucles pour répéter des actions dans des flux de travail pour Azure Logic Apps

S’applique à : Azure Logic Apps (Consommation + Standard)

Pour répéter des actions dans un flux de travail d'application logique, vous pouvez ajouter la boucle Pour chaque ou Until à votre flux de travail, en fonction des besoins de votre scénario.

Remarque

Vous cherchez de la documentation sur les boucles dans Power Automate ? Voir Utiliser des boucles.

En fonction de votre cas d’usage, vous pouvez choisir parmi les types d’actions de boucle suivants :

• Pour répéter une ou plusieurs actions sur les éléments d’un tableau ou d’une collection, ajoutez l’action For each à votre workflow.

  Sinon, si vous disposez d’un déclencheur qui peut gérer des tableaux et que vous souhaitez exécuter une instance de workflow pour chaque élément de tableau, vous pouvez fragmenter le tableau en définissant la propriété Split on du déclencheur.

• Pour répéter une ou plusieurs actions jusqu’à ce qu’une condition soit remplie ou qu’un état spécifique change, ajoutez l’action Until à votre flux de travail.

  Votre workflow exécute d’abord toutes les actions dans la boucle, puis vérifie la condition ou l’état. Si la condition est remplie, la boucle s’arrête. Dans le cas contraire, la boucle se répète. Si vous souhaitez en savoir plus sur les limites par défaut et maximale du nombre de boucles Until que l’exécution d’un workflow peut avoir, consultez Limites de simultanéité, de bouclage et de décomposition.

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.

• Ressource d’application logique dans laquelle vous pouvez créer et modifier un flux de travail. Découvrez ce qu’est Azure Logic Apps.

• Ressource et flux de travail d’application logique dans lesquels vous souhaitez répéter une action dans une boucle et un déclencheur qui démarre le flux de travail.

  Avant de pouvoir ajouter une action de boucle, votre workflow doit commencer par un déclencheur comme première étape. Pour plus d’informations, consultez Ajouter un déclencheur ou une action pour générer un flux de travail.

Les étapes suivantes utilisent le portail Azure, mais avec l’extension Azure Logic Apps appropriée, vous pouvez également utiliser les outils suivants pour créer des flux de travail d’application logique :

• Flux de travail de consommation : Visual Studio Code
• Workflow Standard : Visual Studio Code

Certaines étapes diffèrent légèrement selon que vous disposez d’un flux de travail Consommation ou Standard.

Pour chaque

L'action Pour chaque fonctionne uniquement sur les tableaux. Cette boucle répète une ou plusieurs actions sur chaque élément d’un tableau. Passez en revue les considérations suivantes pour chaque action :

• L’action Pour chaque peut traiter un nombre limité d’éléments de tableau. Pour connaître cette limite, consultez Limites de concurrence, de bouclage et de décomposition.

• Par défaut, les cycles ou itérations d’une action Pour chaque s’exécutent en même temps en parallèle.

  Ce comportement diffère de la boucle Appliquer à chaque de Power Automate où les itérations s’exécutent l’une après l’autre, ou séquentiellement. Si votre cas d’usage nécessite un traitement séquentiel, vous pouvez configurer Pour que chaque itération s’exécute une par une. Par exemple, pour suspendre l’itération suivante dans une action Pour chaque à l’aide de l’action « Retarder », vous devez définir chaque itération pour qu’elle s’exécute de façon séquentielle.

  L’exception au comportement par défaut est celle de l’action Pour chaque imbriquée, où les itérations s’exécutent toujours séquentiellement et non en parallèle. Pour exécuter des actions simultanément sur des éléments de tableau dans un imbrication pour chaque action, créez et appelez un flux de travail enfant.

• Pour obtenir des résultats prévisibles à partir d’opérations exécutées sur des variables pendant chaque itération d’action, exécutez ces itérations de manière séquentielle. Par exemple, quand une itération exécutée simultanément se termine, les opérations Incrémenter une variable, Décrémenter une variable, et Ajouter à la variable retournent des résultats prévisibles. Toutefois, pendant chaque itération de la boucle s’exécutant simultanément, ces opérations peuvent retourner des résultats imprévisibles.

• Les actions d’une boucle Pour chaque utilisent la fonction item() pour référencer, puis traiter chaque élément du tableau. Si vous spécifiez des données qui ne sont pas présentes dans le tableau, le workflow échoue.

L’exemple de workflow suivant envoie un résumé quotidien pour le flux RSS d’un site web. Le workflow utilise une action Pour chaque qui envoie un e-mail pour chaque nouvel élément.

1. Dans le Portail Microsoft Azure, créez un workflow d’application logique avec les étapes suivantes dans l’ordre spécifié :

   • Le déclencheur RSS nommé Lors de la publication d’un élément de flux

     Suivez ces étapes générales pour ajouter un déclencheur à un workflow d’application logique Consommation ou Standard .

   • L’action Outlook.com ou Office 365 Outlook nommée Envoyer un e-mail

     Suivez ces étapes générales pour ajouter une action à un flux de travail d’application logique Consommation ou Standard .

2. Suivez les mêmes étapes générales pour ajouter l’action Pour chaque entre le déclencheur RSS et l’action Envoyer un e-mail dans votre flux de travail.

3. Générez maintenant la boucle :

   1. Dans l’élément Pour chaque élément, sélectionnez dans la zone Sélectionner une sortie à partir de la zone Étapes précédentes , puis sélectionnez l’icône éclair.

   2. Dans la liste de contenu dynamique qui s’ouvre, sous Lorsqu’un élément de flux est publié, sélectionnez Liens de flux, qui est une sortie de tableau à partir du déclencheur RSS.

      Remarque

      Si le résultat Liens du flux n’apparaît pas, sélectionnez Afficher plus en regard de l’étiquette de section du déclencheur. Dans la liste de contenus dynamiques, vous pouvez sélectionner uniquement les résultats des étapes précédentes.

      

      Lorsque vous avez terminé, le résultat de tableau sélectionné s’affiche comme dans l’exemple suivant :

      

   3. Pour exécuter une action sur chaque élément du tableau, faites glisser l’action Envoyer un e-mail dans la boucle Pour chaque.

      Maintenant, votre workflow ressemble à l’exemple suivant :

      

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

5. Pour tester manuellement votre flux de travail, dans la barre d’outils du concepteur, sélectionnez Exécuter>Exécuter.

Définition d’action Pour chaque (JSON)

Si vous travaillez en mode Code, vous pouvez définir l’action For_each dans la définition JSON de votre workflow. Par exemple :

"actions": {
   "For_each": {
      "actions": {
         "Send_an_email_(V2)": {
            "type": "ApiConnection",
            "inputs": {
               "body": {
                  "Body": "@{item()}",
                  "Subject": "New CNN post @{triggerBody()?['publishDate']}",
                  "To": "me@contoso.com"
               },
               "host": {
                  "connection": {
                     "name": "@parameters('$connections')['office365']['connectionId']"
                  }
               },
               "method": "post",
               "path": "/v2/Mail"
            },
            "runAfter": {}
         }
      },
      "foreach": "@triggerBody()?['links']",
      "runAfter": {},
      "type": "Foreach"
   }
},

Pour chaque : exécution séquentielle

Par défaut, les itérations d'une action Pour chaque s'exécutent en même temps en parallèle. Toutefois, si vous avez des boucles imbriquées ou que vous avez des variables à l’intérieur des boucles où vous attendez des résultats prévisibles, vous devez exécuter ces boucles une par une séquence séquentielle.

1. Dans le concepteur, sélectionnez l’action Pour chaque action pour ouvrir le volet d’informations, puis sélectionnez Paramètres.

2. Sous Contrôle d’accès concurrentiel, remplacez le paramètre Désactivé par Activé.

3. Déplacez le curseur Degré de parallélisme sur 1.

   

Définition de l’action « Pour chaque » (JSON) : exécution séquentielle

Si vous travaillez en mode code avec l’action dans la For_each définition JSON de votre workflow, ajoutez le operationOptions paramètre et définissez la valeur du paramètre sur Sequential:

"actions": {
   "For_each": {
      "actions": {
         "Send_an_email_(V2)": { }
      },
      "foreach": "@triggerBody()?['links']",
      "runAfter": {},
      "type": "Foreach",
      "operationOptions": "Sequential"
   }
}

Jusqu’à

L’action Jusqu’à s’exécute et répète une ou plusieurs actions jusqu’à ce que la condition spécifiée requise soit remplie. Si la condition est remplie, la boucle s’arrête. Dans le cas contraire, la boucle se répète. Pour connaître les limites par défaut et maximales du nombre d’actions ou d’itérations Until, consultez les limites de concurrence, de bouclage et de débat.

La liste suivante contient certains scénarios courants dans lesquels vous pouvez utiliser une action Jusqu’à :

• Appeler un point de terminaison jusqu’à obtenir la réponse souhaitée.

• Créer un enregistrement dans une base de données. Attendre qu’un champ spécifique dans cet enregistrement soit approuvé. Continuer le traitement.

Par défaut, l’action Until réussit ou échoue de la manière suivante :

• La boucle Until réussit si toutes les actions à l’intérieur de la boucle réussissent et si la limite de boucle est atteinte, sur la base du comportement run after.

• Si toutes les actions de la dernière itération de la boucle Until réussissent, la boucle Until entière est marquée comme Réussie.

• Si une action échoue dans la dernière itération de la boucle Until , la boucle Until entière est marquée comme ayant échoué.

• Si une action échoue dans une itération autre que la dernière itération, l’itération suivante continue à s’exécuter et l’action Until entière n’est pas marquée comme Ayant échoué.

  Pour que l’action échoue à la place, modifiez le comportement par défaut dans la définition JSON de la boucle en ajoutant le paramètre nommé operationOptions, et en définissant la valeur FailWhenLimitsReachedsur , par exemple :

  "Until": {
     "actions": {
       "Execute_stored_procedure": {
         <...>
         }
       },
       "expression": "@equals(variables('myUntilStop'), true)",
       "limit": {
         "count": 5,
         "timeout": "PT1H"
       },
       "operationOptions": "FailWhenLimitsReached",
       "runAfter": {
       "Initialize_variable_8": [
         "Succeeded"
       ]
     },
  "type": "Until"
  }
  

Dans l’exemple de workflow suivant, à partir de 8h00 chaque jour, l’action Jusqu’à incrémente une variable jusqu’à ce que sa valeur soit égale à 10. Le workflow envoie ensuite un e-mail qui confirme la valeur actuelle. L’exemple utilise Office 365 Outlook, mais vous pouvez utiliser n’importe quel fournisseur de messagerie pris en charge par Azure Logic Apps. Si vous utilisez un autre compte de messagerie, les étapes générales restent les mêmes, mais semblent légèrement différentes.

1. Dans le Portail Azure, créez une ressource d’application logique avec un flux de travail vide. Reportez-vous à la procédure précédente.

2. Dans le concepteur, suivez les étapes générales pour ajouter le déclencheur prédéfini Planification nommé Périodicité à votre flux de travail Consommation ou Standard .

3. Dans le déclencheur Périodicité , spécifiez l’intervalle, la fréquence et l’heure du déclenchement du déclencheur.

   Paramètre	Valeur
   Intervalle	1
   Fréquence	Jour
   Aux heures indiquées	8
   Aux minutes indiquées	00

   À ces heures et à ces minutes s’affichent après avoir défini La fréquence sur Jour.

   Lorsque vous avez terminé, le déclencheur Périodicité ressemble à l’exemple suivant :

   

4. Sous le déclencheur, suivez ces étapes générales pour ajouter l’action intégrée Variables nommée Initialize variables à votre flux de travail Consommation ou Application logique Standard .

5. Dans l’action Initialiser des variables , fournissez les valeurs suivantes :

   Paramètre	Valeur	Descriptif
   Nom	Limite	Nom de votre variable
   Type	Integer	Type de données de votre variable
   Valeur	0	Valeur de départ de votre variable

   

6. Sous l’action Initialiser des variables , suivez ces étapes générales pour ajouter l’action intégrée Control nommée Until à votre flux de travail Consommation ou Application logique Standard .

7. Dans l’action Jusqu’à, indiquez les valeurs suivantes pour configurer la condition d’arrêt de la boucle.

   1. Sélectionnez à l’intérieur de la zone Loop Until , puis sélectionnez l’icône de foudre pour ouvrir la liste de contenu dynamique.

   2. Dans la liste, sous Variables, sélectionnez la variable nommée Limit.

   3. Sous Nombre, entrez 10 comme valeur de comparaison.

   

8. Dans l’action Until , sélectionnez +>Ajouter une action.

9. Suivez ces étapes générales pour ajouter l’action intégrée Variables nommée Incrément à l’action Until dans votre flux de travail Consommation ou Application logique Standard .

10. Dans l’action Incrémenter une variable, indiquez les valeurs suivantes pour incrémenter la valeur de la variable Limit de 1 :

    Paramètre	Valeur
    Limite	Sélectionnez la variable Limit.
    Valeur	1

    

11. En dehors et sous l’action Until , suivez ces étapes générales pour ajouter une action qui envoie des e-mails dans votre flux de travail Consommation ou Application logique Standard .

    Cet exemple se poursuit en utilisant l’action Office 365 Outlook nommée Envoyer un e-mail.

12. Dans l’action « E-mail », indiquez les valeurs suivantes :

    Paramètre	Valeur	Descriptif
    À	< e-mail-address@domain>	Adresse e-mail du destinataire. Pour effectuer le test, utilisez votre propre adresse e-mail.
    Subject	Valeur actuelle pour la variable « Limit » est la suivante :Limite	L’objet de l’e-mail. Pour cet exemple, vérifiez que vous incluez la variable Limit pour confirmer que la valeur actuelle répond à votre condition spécifiée : 1. Sélectionnez à l’intérieur de la zone Objet , puis sélectionnez l’icône éclair. 2. Dans la liste de contenu dynamique qui s’ouvre, en regard de l’en-tête de section Variables , sélectionnez Plus d’informations. 3. Sélectionnez Limit.
    Corps	< e-mail-content>	Contenu de l’e-mail à envoyer. Pour cet exemple, entrez le texte de votre choix.

    Lorsque vous avez terminé, votre action « E-mail » ressemble à l’exemple qui suit :

    

13. Enregistrez votre flux de travail.

Tester votre workflow

Pour tester manuellement votre flux de travail d’application logique :

• Dans la barre d’outils du concepteur, dans l’option Exécuter , sélectionnez Exécuter.

Lorsque votre workflow s’exécute, vous recevez un e-mail avec le contenu spécifié :

Empêcher les boucles infinies

L’action Until arrête l’exécution en fonction des paramètres facultatifs Count and Timeout . Veillez à définir ces valeurs de paramètre en conséquence :

Paramètre	Descriptif
Nombre	Nombre maximal d’itérations qui s’exécutent avant que la boucle ne quitte. Pour en savoir plus sur les limites par défaut et maximale du nombre d’actions Jusqu’à qu’un workflow peut avoir, consultez Limites de simultanéité, de bouclage et de décomposition.
Délai d'expiration	Durée maximale d’exécution de l’action Jusqu’à (itérations comprises) avant que la boucle ne quitte. Cette valeur est spécifiée au format ISO 8601, et est évaluée pour chaque itération. Si une action dans la boucle dure plus longtemps que la limite de délai d’attente, l’itération en cours ne s’arrête pas. Toutefois, l’itération suivante ne démarre pas, car la condition de limite de délai d’attente n’est pas remplie. Pour obtenir les limites par défaut et maximale de la valeur Délai d’attente, consultez Limites de simultanéité, de bouclage et de décomposition.

Définition (JSON) de la boucle « Until »

Si vous travaillez en mode Code, vous pouvez définir une action Until dans la définition JSON de votre workflow. Par exemple :

"actions": {
   "Initialize_variable": {
      // Definition for initialize variable action
   },
   "Send_an_email": {
      // Definition for send email action
   },
   "Until": {
      "type": "Until",
      "actions": {
         "Increment_variable": {
            "type": "IncrementVariable",
            "inputs": {
               "name": "Limit",
               "value": 1
            },
            "runAfter": {}
         }
      },
      "expression": "@equals(variables('Limit'), 10)",
      // To prevent endless loops, an "Until" loop 
      // includes these default limits that stop the loop. 
      "limit": { 
         "count": 60,
         "timeout": "PT1H"
      },
      "runAfter": {
         "Initialize_variable": [
            "Succeeded"
         ]
      }
   }
}

Cet exemple de boucle Until appelle un point de terminaison HTTP, qui crée une ressource. La boucle s’arrête quand le corps de réponse HTTP est retourné avec l’état Completed. Pour empêcher les boucles infinies, la boucle s’arrête aussi quand l’une de ces conditions est remplie :

• La boucle s’est exécutée 10 fois comme spécifié par l’attribut count. La valeur par défaut est de 60 fois.

• La boucle s’est exécutée pendant deux heures comme spécifié par l’attribut timeout au format ISO 8601. La valeur par défaut est d’une heure.

"actions": {
   "myUntilLoopName": {
      "type": "Until",
      "actions": {
         "Create_new_resource": {
            "type": "Http",
            "inputs": {
               "body": {
                  "resourceId": "@triggerBody()"
               },
               "url": "https://domain.com/provisionResource/create-resource"
            },
            "runAfter": {},
            "type": "ApiConnection"
         }
      },
      "expression": "@equals(body('Create_new_resource'), 'Completed')",
      "limit": {
         "count": 10,
         "timeout": "PT2H"
      },
      "runAfter": {}
   }
}

Contenu connexe

• Exécuter des étapes en fonction d’une condition (action conditionnelle)
• Exécuter différentes étapes en fonction de valeurs spécifiques (action de commutation)
• Exécuter ou joindre des étapes (branches) parallèles
• Étendues : Exécuter des étapes en fonction de l’état d’un groupe