Flux translyticaux Power BI & Fabric : créez des dashboards vraiment actionnables

Article rédigé par Nathanael Aouizerat

Depuis mai 2025, il est possible d’enrichir ses dashboard Power BI avec des fonctions applicative à destination des utilisateurs. On appelle cela des flux translyticaux. Ces flux permettent plusieurs actions comme la mise à jour d’enregistrements ou déclencher des actions dans d’autres systèmes (mail, API, etc…). 

Dans cet article, nous allons voir les étapes pour créer un flux dans un dashboard. L’objet du dashboard est de suivre des inscriptions a des formations et leur planification. Nous allons donc créer un flux sur le dashboard qui permettra de planifier une formation et de s’y inscrire. 

---

Créer une base de données SQL dans Fabric

Les flux que nous allons créer vont venir principalement modifier des données, en plus de déclencher d’autres évènements.

Pour créer une base de données SQL :

1. Naviguez vers le workspace de votre choix dans Fabric
2. Cliquez sur <<Nouvel élément>>
3. Sélectionnez SQL Database.
4. Nommez la base et cliquez sur <<Créer>

Vous pouvez alors importer vos données dans différentes tables. La création des différentes tables ne sera pas traitées dans cet article.

---

Créer un module <<User Data Function>>

Pour créer un élément <<User Data Function>> ou <<Fonctions de données utilisateur>> en français :

1. Naviguez vers le workspace de votre choix dans Fabric
2. Cliquez sur <<Nouvel élément>>
3. Choississez Fonctions de données utilisateur dans la section <<Développer des données>>
4. Nommer le module et cliquez sur <<Créer>>
5. Cliquez après sur <<Nouvelle fonction>>

À la fin de ces étapes vous arriverez dans un environnement de développement en python, avec une première fonction à la <<hello world>> en exemple.

Il faut maintenant connecter le module à la base de données précédemment créée :

1. Cliquez sur <<Gérez les connexions>>
2. Par la suite, sur <<Ajouter une connexion>>

3. Le catalogue OneLake s’ouvrira et vous pourrez rechercher la base de données créée (dans notre cas : NAO_BDD_Formations)
4. Une fois revenu sur l’écran précédent, notez bien la valeur du champ <<Alias>>, nous allons en avoir besoin plus tard !

Une fois la base de données connecté, nous pourrons alors la modifier avec les fonctions que nous allons coder tout de suite. 

Nous allons écrire une fonction python avec, cependant, quelques éléments spécifiques.  

Premièrement, pour être utilisable, la fonction nécessite deux décorateurs : 

@udf.connection(argName="sqlDB", alias="NAOBDDFormation")
@udf.function()

Le premier décorateur vient apporter la connexion et le second vient apporter toutes les méthodes qui permettra à la fonction d’être appelée par Power BI. 

Second élément, un paramètre sqlDB est obligatoire dans la fonction, et la fonction doit renvoyer une chaine de caractères : 

def creation_session(sqlDB: fn.FabricSqlConnection, module:str, 
dateSession:datetime) -> str: 

Voici un exemple de fonction commentée. La fonction exécute une requête SQL pour intégrer les données en paramètre : 

@udf.connection(argName="sqlDB", alias="NAOBDDFormation")@udf.function() def creation_session(sqlDB: fn.FabricSqlConnection, module: str, dateSession: datetime) -> str: 
        try:
            # Établir une connexion à la base de données à partir de l’objet passé en paramètre 
            connection = sqlDB.connect()
            cursor = connection.cursor() 
                
            # Récupère la date/heure actuelle pour usage éventuel (ici non utilisée) 
            dt = datetime.now()
            # Prépare les données à insérer dans la table Session 
            # dateSession : date de la formation (paramètre de la fonction) 
            # module : nom du module de formation 
            # 1 : durée en heures (valeur par défaut) 
            # 10 : nombre maximum de participants (valeur par défaut)
            data = (dateSession, module, 1, 10)
                
            # Journalisation d'une étape d'information 
            logging.info("Ajout d'une session ...") 

            # Requête SQL paramétrée 
            insert_query = """ 
            INSERT INTO [dbo].[Session]  
            ([DateFormation], [ModuleFormation], [DureeHeure], [NbMaxParticipant])  
            VALUES (?, ?, ?, ?); 
            """ 

            # Exécution de la requête SQL avec les paramètres fournis 
            cursor.execute(insert_query, data) 
            logging.info("Une session a été ajoutée à la table Session")

            # Validation (commit) de la transaction dans la base 
            connection.commit() 

           # Fermeture du curseur et de la connexion pour libérer les ressources 
            cursor.close()
            connection.close()  

            # Retourne un message confirmant la création réussie
            return "La session a été créée" 

        except Exception as e: 
           # Capture toute erreur survenue, renvoie une exception personnalisée et son message détaillé 
        raise fn.UserThrownError("We ran into an issue.", {"Error:": str(e)})

Si besoin, on peut intégrer des bibliothèques de fonctions. Dans l’exemple nous avons intégré notamment la librairie datetime pour récupérer la date du jour.

Une fois la fonction codée, on publie le module pour l’utiliser par la suite.

On peut alors créer plusieurs fonctions qui vont modifier ou supprimer une entrée en modifiant uniquement la requête SQL exécutée : 

@udf.connection(argName="sqlDB", alias="NAOBDDFormation") 
@udf.function() 
def modif_session(sqlDB: fn.FabricSqlConnection, module:str, dateSession:datetime, cle:int) -> str: 
        try: 
            connection = sqlDB.connect()  
            cursor = connection.cursor() 

            dt = datetime.now() 
            data = (dateSession, module, cle) 

            logging.info("Ajout d'une session ...") 
            # Insert data into the table 
            insert_query = "UPDATE [dbo].[Session] SET [DateFormation] = ?, [ModuleFormation] = ? WHERE [Cle] = ?;" 
            cursor.execute(insert_query, data) 

            # Commit the transaction 
            connection.commit() 

            # Close the connection 
            cursor.close()
            connection.close()                
            return "La session a été modifiée" 
        except Exception as e: 
            raise fn.UserThrownError("We ran into an issue.", {"Error:": str(e)}) 

@udf.connection(argName="sqlDB", alias="NAOBDDFormation") 
@udf.function() 
def suppr_session(sqlDB: fn.FabricSqlConnection, cle:int) -> str: 
        try: 
            connection = sqlDB.connect()  
            cursor = connection.cursor() 

            data = (cle) 

            logging.info("Ajout d'une session ...") 
            # Insert data into the table 
            insert_query = "DELETE [dbo].[Session] WHERE [Cle] = ?;" 
            cursor.execute(insert_query, data) 

            # Commit the transaction 
            connection.commit() 

            insert_query = "DELETE [dbo].[Inscriptions] WHERE [NumeroFormation] = ?;" 

            cursor.execute(insert_query, data) 

            # Commit the transaction 
            connection.commit() 

            # Close the connection 
            cursor.close() 
            connection.close()                
            return "La session a été supprimé"
        except Exception as e:
            raise fn.UserThrownError("We ran into an issue.", {"Error:": str(e)}) 

Au-delà d’exécuter une simple requête SQL, il est tout à fait possible de faire d’autres actions, comme se connecter à un serveur mail et d’envoyer un courrier à une adresse paramétrée : 

@udf.function() 
def envoi_mail(email:str, sujet:str, text:str) -> str: 
        # Configuration
        expediteur = "XXXXXXXXX@gmail.com" 
        destinataire = email 
        mot_de_passe = "XXXX XXXX XXXX XXXX"  # Mot de passe d'application Gmail

        # Création du message 
        msg = MIMEMultipart() 
        msg["From"] = expediteur 
        msg["To"] = destinataire 
        msg["Subject"] = sujet 

        # Corps du mail
        msg.attach(MIMEText(text, "plain")) 

try: 
        # Connexion au serveur SMTP de Gmail 
        serveur = smtplib.SMTP("smtp.gmail.com", 587) 
        serveur.starttls()  # Sécurise la connexion 
        serveur.login(expediteur, mot_de_passe) 
        serveur.sendmail(expediteur, destinataire, msg.as_string()) 
        return("Email envoyé avec succès") 
except Exception as e: 
        raise fn.UserThrownError("We ran into an issue.", {"Error:": str(e)}) 
finally: 
        serveur.quit()

Une fois notre code créé, rendez-vous sur Power BI desktop pour configurer notre dashboard.  

---

Configurer le dashboard

Sur notre dashboard que l’on aura créé et connecté à ses données (celle du serveur SQL précédemment créé), nous allons ajouter des éléments qui vont permettre d’appeler les fonctions que l’on a créée avec leurs paramètres respectifs. Ces éléments sont les boutons d’action qui vont servir à appeler les fonctions, et des slicers (nouveaux) qui vont nous permettre de récupérer des informations à intégrer en paramètre.

Sur l’onglet « Planifier une session » nous avons créé trois boutons, correspondant aux trois fonctions « créer », « modifier », ou « supprimer ». Nous avons également créé des slicers qui vont nous permettre de récupérer des éléments pour paramétrer notre fonction. 

Attention : uniquement les « nouveaux » segments fonctionnent avec les fonctions.

1. Une fois le bouton créé, allez dans l’onglet « Format » 
2. Dans la section « Action » et dans le champ « Type », sélectionnez “Fonction de donnée”. 
3. Enfin en cliquant sur F(x) vous pourrez sélectionner le module « User Data Function » et la fonction souhaitée que l’on a précédemment créée 

Automatiquement, des champs correspondant aux paramètres de la fonction vont apparaitre. 

Vous pourrez choisir les slicers dont les valeurs sélectionnées vont être intégrées en paramètre de la fonction. 

Il est tout à fait possible également de récupérer une valeur d’un champ en cliquant sur le bouton “fx”.

Une fois le Dashboard publié, on pourra sélectionner nos informations, une date et la fonction seront lancées en cliquant sur le bouton « Planifier la formation ». Quelques secondes plus tard, lorsque le modèle sémantique se met à jour, la ligne intégré apparaitra dans la table et par conséquent dans le visuel. 

---

Remarque sur la sécurité

Pour octroyer (ou limiter les droits d’exécution des fonctions) : 

1. Cliquez sur les « … » dans l’explorateur d’objet de Fabric 
2. Puis sur « Gérer les autorisations » 

De cette fenêtre on peut ajouter un utilisateur et octroyer les droits nécessaires. L’autorisation « Exécution » est celle qui nous concerne en particulier et qui permettra à l’utilisateur d’exécuter toutes les fonctions de l’objet 

Remarque : les droits d’accès du dashboard et celles de l’objet “User Data Functions” ne s’hérite pas entre eux. Ils sont indépendants. 

---

Conclusion

En définitive les flux translyticaux permettent de rapprocher l’analyse et la décision dans un même et unique « pipeline » : des actions peuvent être prise tout de suite dans une gouvernance robuste et unique managé par Fabric et Power BI. 

Le développement de tels flux sont surtout adaptés à des scénarios de mises à jour légères, et est moins adapté dans un cadre de traitement de données beaucoup plus important. 

Au-delà de simple mise a jour de données, on peut en l’occurrence imaginer d’autres applications métiers : appels API, validation ou approbation, etc. 

Vous voulez automatiser vos processus avec un simple bouton ? 
Parlons-en et voyons comment Power BI et Fabric peuvent vous aider à optimiser votre temps !