Comment gérer les erreurs sur Make ? Make est un outil incroyable pour automatiser et créer des liaison entre des applications qui n’ont rien à voir entre elles. Son fonctionnement en glisser-déposer rend sa prise en main très agréable et rapide. Seulement, il y a un point sur lequel beaucoup de débutant font l’impasse : la gestion des erreurs.
Dans cet article je vais t’expliquer pourquoi tu dois gérer les erreurs sur Make et comment tu peux le faire. Avant cela, si tu ne connais pas Make, je t’encourage vivement à faire un tour sur cet article où je te partage le potentiel de Make et pourquoi tu dois impérativement l’intégrer dans ton activité.
Pourquoi tu dois gérer les erreurs Make ?
Créer une automatisation sur Make est assez simple. Globalement, quand on a compris son fonctionnement, on ajoute des modules les uns à la suite des autres, on les assemble, on active l’automatisation chaque jour à une heure précise et ça y’est !
Dès lors, notre système se lance tous les jours et nous gagnons un temps considérable qu’on peut utiliser pour faire avancer notre activité encore plus efficacement !
Mais il y a un souci dans ce monde idyllique que je te présente là.
Que ce soit en automatisation ou en code, il y a TOUJOURS des problèmes. Des problèmes que même le plus grand génie de ce monde ne saurait prévoir.
Cela pourrait être un problème :
- sur les serveurs de Make
- sur le site de ton client
- dans les données reçues par l’automatisation
- de l’application Make utilisée
La réaction de Make en cas d’erreur
En cas d’erreur, Make est catégorique.
Même si ton automatisation fonctionne parfaitement chaque jour depuis 2 ans, dès la première erreur reçue, il va désactiver ton automatisation.
Pas d’avertissement, pas de système de nombre d’erreurs, NON.
Automatisation désactivée. Pour la réactiver, tu dois régler le problème.
La réaction du débutant
Quand un tel cas arrive, on va donc regarder d’où vient l’erreur. La-dessus, le système de Make est vraiment bien fait. On sait exactement quel module a provoqué l’erreur et on a un message souvent très explicit du problème rencontré.
Un débutant, en voyant ça, modifiera le module en conséquence pour empêcher l’erreur de se reproduire de nouveau.
Il fermera l’automatisation puis dira à son client « C’est bon, c’est réglé ».
Jusqu’à la prochaine erreur.
Quand on débute, cette manière de travailler peut fonctionner. Parce que les clients ne sont pas nombreux, qu’on a le temps de gérer tous les scénarios en ré-activant ceux qui en ont besoin. Mais tu comprends bien qu’avec plusieurs dizaines de client, tout devient compliqué.
Parfois la situation peut être plus dramatique. Il peut arriver que les scénarios soient hébergés sur la version Make de ton client, pas directement sur la tienne.
Donc quand un scénario sera désactivé, tu ne recevras aucune notification par mail. C’est ton client qui découvrira que ses automatisations ne fonctionnent plus, pas toi.
Et il viendra te le dire de nouveau. Et ce, continuellement.
C’est une situation qu’aucun prestataire de service ne souhaite rencontrer. On perd toute crédibilité aux yeux de notre client, qui perd confiance en nous à chaque fois qu’il nous contacte pour régler un problème d’automatisation désactivée.
La solution : Gérer les erreurs Make dans tes scénarios
La solution pour empêcher Make de désactiver tes automatisations, c’est de gérer les erreurs de tes scénarios.
Ainsi, quand un module Make rencontrera une erreur, Make agira en conséquence, comprendra l’erreur et annulera l’action du module ou directement l’automatisation en cours.
Mais sans la désactiver indéfiniment.
Gérer les erreurs te permet alors d’avoir un contrôle sur les erreurs de tes modules sans arrêter leur fonctionnement.
Parfois, l’erreur se produit simplement une fois à cause d’un caractère spécial ou d’une donnée manquante. Et bien Make annulera l’exécution de cette automatisation en particulier, et fonctionnera toujours.
Comment gérer les erreurs Make
Ajouter des modules sur Make, c’est facile. On clique sur le + et les modules apparaissent.
La raison pour laquelle peu de personnes gèrent leurs erreurs dans leurs scénarios Make, c’est notamment parce que la fonctionnalité « Gestion d’erreurs » n’est pas mise en avant par le logiciel.
Pour ajouter un gestionnaire d’erreur sur un module, fais un clic droit, puis clique sur « Add error handler ».
Une nouvelle branche est alors créée. Elle est différente des autres puisque les cercles qui font la liaison entre les modules sont vides (ils sont pleins dans les branches classiques). Cette branche sera traversée uniquement en cas d’erreur.
Les modules d’erreur Make
Une fois la branche d’erreur créée, elle fonctionne comme une branche classique.
Tu peux y ajouter toute sorte de modules qui seront exécutés comme d’habitude, mais uniquement si le module choisi retourne une erreur.
La seule différences, c’est que dans ta liste de modules, tu en as 5 nouveaux que nous n’avons pas d’habitude. Il s’agit des modules d’erreur de Make.
- Break
- Commit
- Ignore
- Resume
- Rollback
Le module Break de Make
Ce module permet d’arrêter un bundle erroné et de l’exclure du flux du scénario Make. Qu’est-ce que ça veut dire ?
Quand un module renvoie plusieurs packs de données (bundles) et que l’un de ces packs provoque une erreur, alors Make le mets de côté pour éviter qu’il ne propage l’erreur dans le reste du scénario.
Make sauvegarde les détails de l’erreur ainsi que le contenu du bundle concerné dans ce qu’on appelle une « exécution incomplète ».
Cela te permet de pouvoir gérer cette erreur plus tard, en sachant exactement les données qui auraient pu causer problème sans gestion d’erreur.
Pour utiliser ce module, tu dois aller dans les paramètres de ton scénario et cocher la case « Allow storing of Incomplete Executions ».
Exemples d’utilisation de Break
Erreurs temporaires : Pour des erreurs comme des dépassement de limite d’API ou des problèmes de connexion, le module « Break » peut temporairement stopper ton scénario et enregistrer l’exécution pour plus tard. Au moins, le reste de ton automatisation n’est pas désactivée.
Exclusions des bundles qui posent problème : Imaginons que tu récupères des données d’une base de données et dans les bundles reçus, il manque une information obligatoire pour le module suivant. Alors Make va le détecter et va juste suspendre ce bundle pour le reste de l’automatisation. Les autres bundles, quant à eux, sont quand même traités.
Le module Commit de Make
On utilise ce module pour valider les changements effectués par un scénario avant qu’une erreur ne survienne. Son rôle principal est d’assurer que les modifications déjà effectuées via les modules précédents sont enregistrées définitivement. Même si le reste du scénario échoue.
Lorsque qu’un module Commit est utilisé, il garantit que les modifications réalisées avant le module de l’erreur sont sauvegardées dans les applications prenant en charge les transactions (étiquette « ACID » sur les modules de Make), comme MySQL ou Data store.
Une fois l’erreur détectée, Make arrête le scénario et ne traite pas les modules et bundles suivants. Cependant, tous les modules activés avant le module d’erreur sont bien enregistrés.
Le module Ignore de Make
Comme son nom l’indique, ce module permet d’ignorer une erreur sur Make. Quand l’erreur est rencontrée, le module va faire comme si rien ne s’était passé et ainsi continuer l’automatisation.
C’est une manière de poursuivre l’automatisation si l’erreur déclenchée n’a pas d’impact direct sur les modules suivants.
Le module Ignore va simplement supprimer le bundle de l’automatisation qui pose problème, et continue avec les données qui fonctionnent.
Il ne faut pas hésiter à souvent ajouter ce module pour gérer les erreurs Make. On s’assure que l’automatisation n’est pas désactivée. Seuls les bundles incomplets et problématiques ne sont pas traités.
Le module Resume de Make
Resume est un module qui permet de gérer les erreurs en remplaçant les données défectueuses par des données de substitution que l’on donne au module.
Au lieu de stopper l’exécution de l’automatisation ou d’ignorer l’erreur, le module insère une donnée de remplacement qui permet au scénario de continuer normalement.
Le module Resume permet donc de poursuivre le flux de l’automatisation et de personnaliser le comportement de l’automatisation avec une valeur choisie. Un module très pratique pour gérer les erreurs Make.
Le module Rollback de Make
Le module Rollback fait l’opposé du module Commit.
Alors que Commit permet d’enregistrer toutes les actions concernant des transactions (étiquettes ACID), le module Rollback quant à lui, annule toutes les transactions effectuées avant l’erreur.
Il peut arriver qu’une transaction soit réussie, mais qu’une erreur survienne plus tard dans l’automatisation. Si c’est le cas, le module Rollback annulera les transactions réalisées (alors que Commit les sauvegardera).
Récapitulatif des modules pour gérer les erreurs Make
| Module | Description | Cas d’utilisation |
|---|---|---|
| Break | Arrête l’exécution d’un scénario immédiatement lorsqu’une erreur survient. | – Ignorer les données erronées dans un scénario de traitement de formulaire. – Poursuivre un scénario de mise à jour de CRM malgré des erreurs sur certains contacts. |
| Commit | Valide toutes les modifications précédentes dans les modules prenant en charge les transactions avant de poursuivre. | – Utiliser une valeur par défaut lorsqu’une donnée obligatoire est manquante dans un formulaire. – Remplacer un champ vide par un placeholder dans un scénario de gestion d’inventaire. |
| Resume | Substitue les données du bundle erroné par des données personnalisées et continue l’exécution du scénario. | – Annuler une transaction bancaire si une erreur survient pendant l’enregistrement. – Restaurer un inventaire à son état initial en cas d’erreur de mise à jour. |
| Ignore | Ignore les erreurs et continue l’exécution du scénario sans traiter les bundles erronés. | – Valider une série d’opérations sur une base de données après chaque mise à jour réussie. – Assurer la cohérence des données après plusieurs mises à jour dans un système ERP. |
| Rollback | Arrête l’exécution du scénario et annule les modifications dans les modules transactionnels en cas d’erreur. | – Arrêter un processus de création d’utilisateurs dans un système si un email est invalide. – Interrompre un scénario de traitement d’images lorsqu’un fichier corrompu est détecté. |
Conclusion : Gérer les erreurs Make – Présentation des modules
Gérer ses erreurs sur Make est important. Cela te permet d’assurer que les données que tu utilises ne viendront pas désactiver ton automatisation.
Selon les automatisations que tu mets en place dans ton activité ou celle de tes clients, une automatisation désactivée peut poser de vrais problèmes.
En utilisant judicieusement les modules d’erreurs que tu utilises, tu pourras faire en sorte que tes automatisations ne soient jamais désactivées. Je te conseille même de t’ajouter une notification interne à chaque fois qu’un erreur handler est actionné.
Cela te permet d’être averti de l’erreur sans même que ton client t’en rende compte. Pour rapidement savoir si oui ou non l’erreur vient de ton système ou des données de ton client.
J’espère que cet article était assez clair pour toi. Si ce n’est pas le cas, dis-le moi en commentaire ou contacte-moi directement sur Instagram.
A bientôt
Nathan
