Utiliser Apply to each et Do until efficacement

Une boucle répète automatiquement les mêmes actions, sans que vous ayez à les recréer pour chaque cas. Dans Power Automate, Apply to each traite un à un les éléments d’une liste, et Do until recommence jusqu’à ce qu’une condition soit remplie. Pour une entreprise, c’est ce qui permet d’envoyer 200 relances personnalisées ou d’attendre qu’un dossier soit validé avant d’aller plus loin, sans intervention humaine.

À quoi servent les boucles dans une entreprise

Prenons une situation type. Chaque lundi, un service comptable relance les clients dont la facture est en retard. Un flux lit la liste des factures, et pour chacune il rédige un e-mail avec le bon montant, la bonne date et le bon interlocuteur. C’est Apply to each : une liste, et le même traitement pour chaque ligne.

Autre cas : un flux demande un export à un logiciel métier, qui met plusieurs minutes à le produire. Le flux vérifie régulièrement si le fichier est prêt et ne continue que lorsqu’il l’est. C’est Do until : on recommence tant que ce n’est pas fini.

Ce que cela change : le traitement ne dépend plus de la disponibilité de quelqu’un et ne saute aucune ligne. Il faut pourtant de la méthode, car une boucle mal réglée peut devenir lente ou consommer une bonne partie de vos quotas. Le reste de ce guide s’adresse à la personne qui construit le flux.

Apply to each : traiter chaque élément d’une liste

Apply to each (« Appliquer à chacun » dans l’interface en français) parcourt un tableau de données : les lignes d’un fichier Excel, les éléments d’une liste SharePoint, les pièces jointes d’un e-mail. La boucle s’arrête seule à la fin de la liste : vous n’avez pas de condition d’arrêt à écrire.

Elle apparaît souvent toute seule. Dès que vous utilisez une valeur issue d’une liste dans une action, le concepteur place cette action dans une boucle. Vérifiez que c’est bien ce que vous voulez : une boucle ajoutée sans y penser est une cause fréquente d’e-mails envoyés en double.

Lire les valeurs de l’élément en cours

Renommez la boucle dès sa création, par exemple Chaque facture. Son nom interne devient alors Chaque_facture, et vos expressions restent lisibles. Pour lire une colonne de la ligne en cours :

items('Chaque_facture')?['EmailClient']

Le ? évite une erreur si la colonne est vide ou absente : le résultat vaut alors null. Pour une lecture plus complète, on peut construire un texte :

concat('Facture ', items('Chaque_facture')?['Numero'], ' : ', items('Chaque_facture')?['Montant'], ' euros')

Dans une expression Power Automate, le séparateur reste la virgule, même dans une interface en français. Pour d’autres fonctions, consultez les expressions indispensables de Power Automate.

Accélérer avec l’exécution en parallèle

Par défaut, les éléments sont traités un par un : le degré de parallélisme vaut 1. Vous pouvez le monter jusqu’à 50 dans les Paramètres de la boucle, avec l’option de contrôle de la concurrence (Concurrency control). Plusieurs éléments sont alors traités en même temps, et le temps total baisse.

Ce réglage a trois contreparties :

• L’ordre de traitement n’est plus garanti. N’activez rien si une ligne dépend de la précédente.
• Les variables deviennent peu fiables. Microsoft le signale clairement : si vos variables doivent donner un résultat prévisible, gardez la boucle en séquentiel. Voyez aussi comment bien utiliser les variables dans un flux.
• Le service visé peut saturer. Le connecteur Excel Online (Business), par exemple, accepte 100 appels par minute et par connexion. Le parallèle ne fera que provoquer des erreurs 429 (« trop de requêtes »). Commencez bas, autour de 5 ou 10, et mesurez.

Do until : répéter jusqu’à une condition

Do until ne dépend pas d’une liste, mais d’un critère que vous définissez. Il exécute d’abord les actions, puis teste la condition. Le contenu de la boucle s’exécute donc au moins une fois, même si la condition est déjà vraie au départ. Les usages typiques sont d’attendre qu’un statut change, qu’un fichier apparaisse ou qu’un service réponde.

Configurer la boucle

1. Tout en haut du flux, ajoutez une action Initialiser une variable nommée Statut, de type chaîne. Une variable ne peut être déclarée qu’au niveau principal du flux, jamais dans une boucle.
2. Ajoutez la boucle Do until et renommez-la Attendre export.
3. Écrivez la condition d’arrêt en mode expression :

   @equals(variables('Statut'), 'Terminé')

4. Dans la boucle, ajoutez l’action qui lit l’état, puis Définir la variable pour mettre à jour Statut.
5. Ajoutez une action Délai en fin de boucle, par exemple une minute. Sans elle, la boucle interroge le service sans répit et épuise vos appels pour rien.
6. Réglez les limites selon l’attente réelle, puis enregistrez.

Pour prévoir plusieurs issues, combinez les tests : la boucle s’arrête si l’export est terminé ou s’il a échoué.

@or(equals(variables('Statut'), 'Terminé'), equals(variables('Statut'), 'Échec'))

L’expression iterationIndexes('Attendre_export') donne le numéro du tour en cours, en partant de 0. C’est utile pour écrire dans un journal ou espacer les essais.

Comprendre les limites de sécurité

Do until a deux garde-fous : 60 tours et une heure (PT1H, au format ISO 8601) par défaut. Le nombre de tours peut monter jusqu’à 5 000. Le délai est testé à chaque tour : une action en cours n’est pas interrompue, mais le tour suivant ne démarre pas.

Le piège classique : atteindre une limite ne fait pas échouer le flux. La boucle s’arrête, et la suite s’exécute comme si tout allait bien. Après la boucle, ajoutez donc une condition qui vérifie que Statut vaut bien « Terminé », et traitez l’autre cas. La documentation du moteur de flux détaille ce comportement. Pour écrire ces tests, voyez aussi les conditions dans Power Automate.

Comparer Apply to each et Do until

Ce que coûte une boucle, et comment l’alléger

Chaque action exécutée compte comme une requête, y compris les réussites, les échecs, les nouvelles tentatives et une simple initialisation de variable. Une boucle de trois actions sur 1 000 lignes consomme donc 3 000 requêtes. La limite officielle est de 6 000 requêtes par 24 h avec une licence Microsoft 365 et de 40 000 avec Power Automate Premium. Cela justifie de réfléchir avant de boucler, comme le montrent les limites officielles des flux.

Quelques réflexes réduisent nettement le coût :

• Filtrer à la source. Utilisez le filtre de l’action qui lit les données, comme Statut eq 'En retard' sur une liste SharePoint. Vous ne recevez que ce qui est utile.
• Filtrer sans boucle. L’action Filtrer un tableau réduit une liste en une seule étape : @equals(item()?['Statut'], 'En retard'). Ici, item() désigne l’élément testé.
• Transformer sans boucle. L’action Sélectionner reconstruit une liste avec les colonnes voulues, sans passer par Apply to each.
• Compter sans boucle. length(body('Filtrer_un_tableau')) donne le nombre d’éléments, sans incrémenter de variable.
• Découper par lots. chunk(body('Filtrer_un_tableau'), 100) regroupe les éléments par paquets de 100, quand le service visé accepte les envois groupés.
• Vérifier la pagination. De nombreuses actions ne renvoient qu’une partie des données : 256 lignes pour Excel, par exemple. Automatiser Excel demande d’activer ce réglage, sinon la boucle ignore des lignes en silence.

Imbriquer des boucles avec prudence

Une boucle dans une boucle multiplie les exécutions : 10 éléments puis 5 sous-éléments font 50 passages, et 1 000 puis 50 en font 50 000. Power Automate tolère jusqu’à 8 niveaux d’imbrication d’actions, mais la lisibilité souffre bien avant. Au-delà de deux niveaux, réorganisez les données en amont, ou confiez la boucle intérieure à un flux enfant, c’est-à-dire un flux appelé par un autre.

Erreurs fréquentes à éviter

• Une condition qui ne peut jamais être vraie. Une faute de frappe (« termine » au lieu de « Terminé ») fait tourner la boucle jusqu’à sa limite. La comparaison equals respecte les accents. Testez avec une vraie valeur.
• Oublier de mettre à jour la variable. Si rien ne change dans la boucle, la condition ne changera pas non plus.
• Déclarer une variable dans une boucle. Ce n’est pas possible : déclarez-la en haut du flux et modifiez-la ensuite.
• Croire qu’une erreur arrête tout. Dans Apply to each, une action en échec n’empêche pas les tours suivants, mais la boucle finit marquée en échec et l’étape suivante est ignorée. Le réglage Exécuter après permet de poursuivre et de traiter ce cas. Voyez comment gérer les erreurs et exceptions dans un flux.
• Laisser passer les erreurs 429. Elles indiquent que vous allez trop vite pour le service visé. Baissez le parallélisme ou ajoutez une pause.

Quand déléguer l’optimisation de vos boucles

Pour parcourir quelques dizaines de lignes une fois par jour, une boucle simple suffit, et vous pouvez tout à fait la construire seul. Confier ce travail à un expert a du sens quand un flux met des heures à finir, reçoit des erreurs 429 répétées, consomme une grande part de vos requêtes, ou traite des volumes qui approchent les limites de votre licence. Même chose si plusieurs flux critiques s’enchaînent. Notre page sur l’automatisation des tâches répétitives avec Power Automate montre ce qu’un flux bien conçu change pour vos équipes.

Questions fréquentes

Quelle est la différence entre Apply to each et Do until ?

Apply to each parcourt une liste existante et s’arrête à la fin. Do until répète des actions jusqu’à ce qu’une condition soit vraie, avec au moins un passage. Le premier sert à traiter des données, le second à attendre un changement d’état.

Comment activer l’exécution en parallèle dans Apply to each ?

Ouvrez les Paramètres de la boucle, activez le contrôle de la concurrence et choisissez un degré de parallélisme, de 1 à 50. N’activez pas ce réglage si la boucle modifie des variables ou si l’ordre compte. Vérifiez aussi les limites d’appels du service visé.

Pourquoi ma boucle Do until ne s’arrête-t-elle pas quand je le pense ?

Le plus souvent, la condition ne devient jamais vraie : variable non mise à jour, valeur mal orthographiée, accent oublié. La boucle tourne alors jusqu’à ses limites, 60 tours ou une heure par défaut, puis le flux continue. Vérifiez la valeur de chaque tour dans l’historique, une fois la boucle terminée.

Combien d’éléments peut-on traiter dans une boucle ?

Apply to each accepte jusqu’à 5 000 éléments en profil de performance bas, et 100 000 pour les autres. La vraie limite est souvent ailleurs : les requêtes consommées et les appels autorisés par le service visé. Au-delà de quelques milliers d’éléments, filtrez ou découpez le traitement en plusieurs exécutions.

Peut-on imbriquer plusieurs boucles ?

Oui, mais le nombre de passages se multiplie. Limitez-vous si possible à deux niveaux, et préparez les données en amont ou utilisez un flux enfant au-delà. Les boucles imbriquées sont aussi plus difficiles à relire dans l’historique.

Comment gérer une erreur sans arrêter le traitement ?

Placez les actions de chaque tour dans une étendue (Scope), puis ajoutez après elle une action réglée avec Exécuter après sur « a échoué ». Elle peut noter la ligne en erreur dans un journal. Les autres éléments continuent d’être traités, et vous savez précisément lesquels reprendre.