Série : Azure “Functions” – Démo

Démonstration de l’écriture d’une Azure Function pour le calcul du PGCD, en utilisant que la ligne de commande. Ecrite en C#

Une “Azure Functions” est la possibilité donnée à l’utilisateur d’exécuter d’un ensemble d’instructions / code sans se préoccuper de l’infrastructure sous-jacente et donc serveur. Pas besoin, de savoir si tout cela est à jour. Microsoft le fait pour nous. Microsoft et sa plateforme Cloud nous apporte les garanties d’élasticité et de haute disponibilité.

Contexte

Fonctionnel

Un petit rappel des avantages de l’utilisation des Azure Functions ;

  • Nous ne voulons pas investir dans l’infrastructure physique on-premise ;
  • Nous n’avons pas les compétences technique pour gérer cette infrastructure réseau,
    des serveurs en interne ;
  • Nous voulons maximiser les dépenses en ne payant qu’à l’utilisation ;
  • Nous voulons la possibilité de monter en charge lors de pique ou l’inverse ;
  • D’avoir en tant que client un contrat comportant des SAL pour éviter toutes
    indisponibilités de service.

Le choix du cloud Azure et des Azure Functions répond en tout point à ces critères.

Technique

Comme nous l’avons vu dans le billet présentant les Azure Functions, elles n’effectuent leurs traitement sur un déclenchement d’un événement. Ce que l’on appel le déclencheur.

Dans notre cas simple nous partirons sur le déclencheur HTTP Trigger.

Il faut que notre fonction puisse nous retourner des informations dans ce cas là nous parlerons donc de liaison qui peuvent être de trois types, on parle alors de direction :

  • liaison IN puisque l’on peut vouloir passer un ensemble d’informations ou quelles 
    proviennent d’un autre service ;
  • liaison OUT puisque elle nous renvois un ensemble d’informations ou quelle 
    veuillent les faire parvenir à un autre service.
  • liaison IN / OUT est un sens spécial.

Tout ces langages sont disponibles sous certaines conditions dont celles de la version du runtime des Azure Functions.

Il faut aussi retenir qu’il existe trois types, on parlera du sens de la liaison :

  • Les liaisons d’entrées ;
  • Les liaisons de sorties ;
  • Plus rarement les liaisons d’entrées/sorties.
Les Liaisons

Les liaisons servent aussi dans le cadre des échanges d’informations entre des services, cela signifie, que si l’on veut faire échanger des informations entre notre fonction azure et une autre service il suffit d’utiliser une liaison, elle va nous éviter d’écrire le code qui va effectuer cette passerelle et tout cela de façon purement déclarative.

Par exemple, notre déclencheur HTTP Trigger est en partie une liaison d’entrée, avec en plus la capacité a exécuter du code.

Développement

Pré-requis

Pour notre développement, nous allons avoir besoin de :

  • D’une souscription (même celle qui est offerte pour la découverte) à Microsoft Azure ;
  • D’un éditeur de code, dans notre cas, nous utiliserons Visual Code ;
  • Du package permettant la création de template d’Azure Function func ;
  • Du package de la commande az PowerShell pour ensuite pouvoir effectuer le déploiement.

Le B-A-BA

Mais d’abord, et c’est une pratique que je fais toujours quand j’étudie des nouvelles technologies, langages ou autres, c’est avant tout savoir comment cela fonctionne.

Mais qu’est-ce-que je veux dire par cela *fonctionne* et bien tout simplement, j’essaie toujours avant de le simplifier la vie au travers d’outils graphique qui nous facilité le travail et nous font gagner du temps, c’est de la faire au travers d’un CLI, ou manuellement pour bien comprendre les interactions, les différents fichiers. Car souvent et malheureusement, je vois des développeurs qui pour schématiser ne savent pas ce qu’ils font ou ne savent pas vraiment comment cela fonctionne et donc sont perdus sans LE bel interface graphique qui fait tout voir même dans certains contexte de trop.

Donc là, nous allons déjà créer, déployer et tester une Azure Fonction en utilisant les CLI respectives az et func. Bon, je vais quand même utiliser Visual Code je vous fais pas l’affront de prendre Notepad ou Notepad++.

Azure in root mode

Contexte

Nous voulons mettre en place une Azure Functions qui va nous permettre de calculer le PGCD de deux entiers naturels (ah les bons souvenirs de l’implémentation de concept mathématiques mais là on fait basique basique).

Définition du PGCD

Allez un petit rappel de la méthode de détermination du PGCD de deux nombres entiers naturels :

PGCD

Nous allons utiliser la méthode des divisions Euclidiennes soit le Lemme d’Euclide suivant. 
Soit un couple d’entiers naturels non nuls (x,y), si des entiers naturels q et r, avec r != 0 sont tels que x = y.q + r, alors : PGCD(x,y) = PGCD (y,r).

Le but c’est que notre fonctions nous retourne tout simplement le PGCD de deux nombres entiers.

Création de notre Azure Function en mode ligne de commande

Nous allons donc dans notre exemple, utiliser la commande CLI d’Azure, on aurait pu aussi utiliser le Cloud Shell ou encore la commande en mode bash. Pour ma part, j’ai une préférence pour la commande PowerShell, mais il faut savoir que c’est trois méthodes sont complément identique au sens fonctionnel, seul la syntaxe change.

Nous allons travailler avec la version 3.x du runtime pour les Azures Functions.

Versions

Au moment, où j’écris cette démonstration j’utilise la dernière version d’ azure cli soit la version 2.10.1 et en ce qui concerne la commande func elle est en version 3.0.2630.

1ere Etape
Objectif

la création du projet/squelette de notre Azure Function et le corps de celle-ci

Pour cela nous allons utiliser la commande func comme suit :

func init PgcdAzureFunctionDemo --dotnet

Lorsque la commande a fini son travail nous devons avoir un répertoire portant le nom de notre projet et les fichiers suivants dans le répertoire :

  • host.json
  • local.settings.json
  • PgcdAzureFunctionDemo.csproj

Là, nous avons le projet mais toujours pas notre fonction, nous allons donc effectuer la commande suivante :

func new --name pgcddemo --template "HTTP Trigger"

Nous obtiendrons un fichier *cs* portant le nom de pgcddemo.cs est qui est la définition de notre fonction azure.

Nous pouvons d’or et déjà vérifier le bon fonctionnement de notre fonction car la ligne de commande nous offre un fonction avec un code fonctionnel, un peu comme le fameux “Hello World” pour cela nous allons simplement exécuter la commande suivante :

 func start

Si tout ce déroule normalement, vous obtiendrez deux lignes similaires suivantes :

 Http Functions:

        pgcddemo: [GET,POST] http://localhost:7071/api/pgcddemo

il suffit de prendre l’URL et de la mettre dans votre navigateur ou Postman pour obtenir un message.

This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.

et si vous ajoutez le paramètre name avec une valeur, dans l’URL comme suit :

http://localhost:7071/api/pgcddemo?name=John%20Doe

Vous devriez avoir le message suivant :

"Hello, John Doe. This HTTP triggered function executed successfully.

A chaque appel de votre fonction vous verrez que le runtime affiche un ensemble d’informations de log et d’informations au format JSON.

Vous pouvez aussi essayer l’URL suivante… Vous pouvez cliquer la zone contenant le smiley !!!

http://localhost:7071/

Voilà, on peut mettre un terme au runtime à l’aide des touches <CTRL>+<C>.

Résumé

Nous avons appris à créer à partir de la ligne de commande CLI :

  • Le projet pour une AzureFunction ;
  • La fonction par elle-même ;
  • Démarrer le runtime 
  • Faire appel à notre fonction.
2nde Etape
Objectif

Développer notre fonction de calcul de PGCD.

Le but de cette article n’est pas de faire un cours d’Algorithmie sur la façon de la développer c’est pour cela que je ne m’attarderai pas sur le corps même de la fonction mais plus sur ce qui gravite autour et qui se rapporte à la fonction azure.

Notre fonction de PGCD va de décomposer comme suit :

  • Des liaisons en entrée : deux paramètres qui se trouvent être les nombres entiers dont 
    on doit déterminer le PGC;
  • Une liaison en sortie : qui est le PGCD de ces deux nombres entiers.

Voici le code de notre fonction, je mettrai à disposition l’ensemble du projet avec la partie déploiement sur Azure à l’aide des Templates ARM que je décrirai dans un prochaine billet.

using System;
    using System.IO;
    using System.Threading.Tasks;
    using Microsoft.AspNetCore.Mvc;
    using Microsoft.Azure.WebJobs;
    using Microsoft.Azure.WebJobs.Extensions.Http;
    using Microsoft.AspNetCore.Http;
    using Microsoft.Extensions.Logging;
    using Newtonsoft.Json;

    namespace PgcdAzureFunctionDemo
    {
        public static class pgcddemo
        {
            [FunctionName("pgcddemo")]
            public static async Task<IActionResult> Run(
                [HttpTrigger(AuthorizationLevel.Function, "get", Route = "pgcd")] 
                HttpRequest req, 
                ILogger log)
            {
                log.LogInformation("PGCD HTTP trigger function processed.");

                int termX = Convert.ToInt32(req.Query["X"]);
                int termY = Convert.ToInt32(req.Query["Y"]);

                int PGCDResult = PerformPGCD(termX,termY);
            
                string responseMessage = $"Azure Function for calculated PGCD({termX},{termY}) is {PGCDResult}";

                return new OkObjectResult(responseMessage);
            }
            private static int PerformPGCD(int x, int y)
            {
                if (y == 0) 
                    return x;

                int reste = x % y;
                int quotient = x /y;

                return PerformPGCD(y, reste);
            }
        }
    }

Exécution

Maintenant il est temps de voir si notre fonction répond bien à nos attentes et pour cela, il suffit d’utiliser la commande suivante :

func start

ensuite à l’aide soit du navigateur utilisez l’url (attention le numéro du port peut varier) :

http://localhost:7071/api/pgcd?x=384&y=124

avec pour résultat le message :

Azure Function for calculated PGCD(384,124) is 4

Vous pouvez aussi utiliser l’outils Postman. Cela vous permettra de changer le verbe par exemple POST est de regarder les logs du runtime (status 404).

Décryptage

Regardons de plus prêt, les particularités de paramétrages de notre fonction.

Attribut ou fichier JSON ?

A savoir que pour une fonction azure en C# nous avons la possibilité de  définir ses options par des
Attributs. En ce qui concerne les langages de script c’est uniquement par le fichier JSON, function.json.
Ce fichier, pour les langages compilés est généré à partir des attributs.

IMPORTANT

Une fonction ne peut répondre qu’à un seul déclenchun billet sur l’utilisation des liaisons IN et liaison OUT entre serviceeur.

[FunctionName("pgcddemo")]

Définition du nom de notre fonction sur une fonction statique de classe et marque le point
d’entrée de la fonction. Le nom de la méthode qui jouera le rôle de point d’entrée peut ne pas être Run.

[HttpTrigger(AuthorizationLevel.Function, "get", Route = "pgcd")] 

Définition du type de notre déclencheur avec en fonction, un nombre de paramètre pour sa configuration. Dans notre cas :

  • le type est HttpTrigger 
  • le niveau d’autorisation est au niveau de la Function cela signifie que la fonctio a une clé API spécifique qui doit être fournie lors des appels à celle-ci ;
  • la ou les méthodes auxquelles la fonction peut être déclenchée dans notre cas,
    elle ne répond que sur un GET ;
  • par défault la route pour l’appel de la fonction est sous la forme : 
    http://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>

Dans notre cas la route sera pgcd au lieu de pgcddemo.

HttpRequest req

C’est le paramètre d’entrée, le Payload (difficilement traduisible par *charge utile*….).

Dans notre cas c’est le type HttpRequest mais un type personnalisé (JSON) peut être aussi utilisé. Là, nous avons accès à l’objet complet de la requête. Cela tombe bien car nous avons des paramètres à récupérer.

OkObjectResult(responseMessage);

Dans un premier temps, nous retournons un message sous la forme du chaine de caractère. La classe OkObjectResult renvoie un message avec un code 200, formattera et déterminera le contenu renvoyé.

Résumé

Voilà vous avez toutes les bases pour écrires vos Azure Functions. On a vu :

  • La mise en place à l’aide des lignes de commandes CLI du projet ;
  • De la création du corps d’une fonction ;- Les bases sur les notions de liaisons, déclencheurs ;
  • Un passage au microscope de notre fonction azure ;
  • L’exécution et tests en local avec Postman ou le navigateur.

Idées

 On pourrait éviter de passer les paramètres en Query mais plutôt sous la forme d’une route ;

  • Au lieu de renvoyer un message plain/text un objet JSON serait beaucoup mieux ;
  • Gestion des erreurs ;
  • Ajouter une autre fonction de PPCD ;
  • Comment gérer le temps d’exécution de notre fonction car il est limité ;
  • Sécurisation des appels.

A venir

Pour ne pas alourdir trop se simple exemple, je ferai :

  • un billet qui sera porté sur le déploiement avec ARM de notre fonction azure ;
  • un billet sur l’appel par une cliente ;
  • un billet sur l’utilisation des liaisons IN et liaison OUT entre service
Stay tuned logo

Frédéric Schmidt

Lead Technical Architect.

Ajouer un commentaire

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

Recent Comments

    %d blogueurs aiment cette page :