Infeeny est dans le magazine Programmez de Mars 2020

Retrouvez nos experts Infeeny dans le numéro 238 du magazine Programmez de Mars 2020.

On y trouve un article sur le monde du développement selon Microsoft avec un focus sur NET 5, la plateforme unifiée qui va sortir en Novembre 2020. C’est la fusion entre NET Framework 4.8 et NET Core 3.1.

Les experts Infeeny qui ont participé à cet article sont Timothé LARIVIERE et Christophe PICHAUD.

Chroniques Techniques sur le JDN

Retrouvez les 3 dernières chroniques de notre Leader de Domaine .NET (ChristopheP) sur le Journal du Net (JDN):

.NET 5 : introduction à la plateforme unifiée de Microsoft – A partir de novembre 2020, Microsoft fusionne .NET Framework et .NET Core 3.x pour créer .NET 5. Une plateforme unifiée pour les développeurs combinant dev .NET, Cloud, gaming, IoT, web, et l’IA.

Comment devenir un développeur expert Microsoft ? – Le monde du développement selon Microsoft est complexe. Il faut savoir décrypter les messages envoyés par le marketing du groupe pour pourvoir lire entre les lignes.

Comment j’ai démystifié Kubernetes, sous Linux Ubuntu – Kubernetes est la technologie cloud à la mode. On en parle partout. J’ai voulu m’intéresser à ça et maîtriser la chose en local avant de la mettre en oeuvre dans le cloud. Voici la synthèse de mon expérience.

Docker et les containers sous Linux

Pré-requis

Vous aurez besoin des éléments suivants pour suivre ce tutoriel :

  • Docker
  • Visual Studio 2019
  • Powershell (ou votre terminal favoris)
  • DotNet

Point d’attention : Il est important que vous pensiez à “switch” votre Docker (si ce n’est pas déjà fait) en Switch to Linux container.

On a essayé de comprendre au mieux le fonctionnement de Docker avec les containers sous Linux depuis un poste sous Windows. Dans cette démarche, nous avons effectués deux essais :

  • Le premier avec Visual Studio et le support Docker intégré.
  • Le second en ligne de commande avec un Dockerfile produit par nos soins.

Exemple d’un projet sous Visual Studio avec support Docker sous Linux

Voici les étapes suivies pour la création du projet (accès pour les néophytes qui ne connaîtraient pas l’environnement de Visual Studio) :

  • Créer un projet WebApplication avec ASP .NET Core 3.1
  • Prendre l’option API et cocher la case “Enable Docker support” avec pour option Linux

Le Dockerfile

Dans le cadre d’un projet avec Docker et des containers sous Linux, le Dockerfile est quelques peu différent :

Pour rappel : lors de la création d’un projet sous Visual Studio avec le support Docker, le Dockerfile est généré automatiquement, avec la commande FROM référençant l’ISO de l’OS choisit (dans notre cas : Linux) avec l’import de la librairie ASP .NET Core.

On a cherché à comprendre pourquoi il y avait deux EXPOSE. En nous renseignant au niveau de la documentation Docker officielle, nous avons compris l’utilité de ceux-ci, son fonctionnement in fine. Néanmoins, nous n’avons pas compris pourquoi notre API ne nous renvoie rien si nous changeons les ports avec la commande suivante (sous Powershell) :

docker run -d -p 42422:80 image_name

Cette commande, permet d’ajouter un host au port 80, dans notre cas 42422. Nous vous expliquerons les différentes options de cette ligne de commande un peu plus bas lors de notre second exemple.

Si on exécute avec le programme à l’aide du bouton “Docker” dans Visual Studio, celui-ci est correctement lancé (par défaut ça vous renverra au WeatherForecast si vous avez pris une API classique).

Exemple d’un projet en ligne de commande avec création d’un Dockerfile

Pour information, le début de notre exemple se base sur le tutoriel suivant qui lui se base sur des containers sous Windows. Par conséquent, il n’y a que le début de notre projet qui ressemble à cette documentation.

Dans le cadre de cet exemple, nous allons mettre en place les éléments suivants :

  • Création d’un dossier de travail
  • Création d’une application .NET
  • Création d’un fichier Dockerfile vide
  • Mise en place du Dockerfile Linux / ASP .NET Core
  • Création d’une image Docker de notre application à partir de notre Dockerfile
  • Création d’un container / exécution de notre container
  • Test de notre application
  • Modification des ports utilisés

Nous allons tout d’abord, créer un dossier dans lequel nous allons effectuer les différentes opérations que nous avons résumés juste au-dessus. Ce dossier s’appellera tuto, pour se faire, nous allons écrire dans notre commande Powershell la commande suivante :

mkdir tuto
cd tuto

La commande mkdir permet de créer le dossier tuto, et la commande cd permet de se placer au niveau du dossier tuto.

Pour la suite, nous allons créer un nouveau projet à l’intérieur du dossier tuto (puisque nous nous y trouvons) :

Nous faisons appel à dotnet car nous souhaitons créer une application .NET, le “new console” permet de définir le type de projet souhaité (ici une application Console). Le -o permet d’indiquer le path du projet app et le -n permet de lui donner un nom en l’occurrence ici : myapp.

Sur l’image ci-dessus, nous pouvons constater que nous nous sommes placés au niveau du dossier app, puis nous avons affichés le contenu du dossier.

Nous avons ensuite exécuter l’application avec la commande :

dotnet run

Cela nous affiche la chaîne de caractère “Hello World!”. En effet, lorsque nous lançons Visual Studio et que nous allons sur le fichier Program.cs, nous voyons que par défaut, la méthode Main affiche la string en question.

Ensuite, nous allons créer notre image Docker. Pour mener a bien cette tâche, nous avons besoin de deux choses :

  • De l’exécutable (.dll)
  • Du Dockerfile

Pour créer l’exécuter, nous avons utilisés la commande suivante:

Celle-ci nous sert à compiler l’application dans le dossier publish. Nous pouvons voir qu’après l’exécution de la commande, le path est indiqué.

Ici, nous vérifions bien que myapp a bien été compilé en myapp.dll.

Nous allons créer le fichier Dockerfile dans le dossier tuto (le fichier doit se trouver à la racine du projet). Il va être composé de la façon suivante :

  • Le FROM ressemble quasiment à celui qui se trouve plus haut dans le premier exemple, à la différence qu’il y a pas de AS base en plus.
  • Le COPY va permettre de copier tout se qui se trouve dans notre dossier publishdans le dossier app, qui lui sera crée dans notre container.
  • Le ENTRYPOINT va permettre d’indiquer à Docker qu’il est une application exécutable en partant de dll.

Nous allons maintenant créer notre image, pour se faire, nous allons retourner à la racine du projet tuto. Puis, nous exécuterons :

Nous allons examiner cette commande ensemble :

  • build : Créer une nouvelle image Docker
  • -t: Permet de donner un nom à cette image
  • -f: Permet de désigner le fichier que nous voulons sélectionner
  • Dockerfile: Correspond à notre fichier et le . derrière sert à indiquer qu’il doit chercher dans le dossier actuel (en l’occurrence le dossier tuto)

Nous pouvons constater, que Docker lors de la première étape va pull l’image de l’ISO, ainsi que les dépendances nécessaires. Durant la deuxième étape, la copie du contenu du dossier publish dans le dossier app va être réalisé. Et enfin, la troisième étape permet d’indiquer à Docker que c’est un exécutable.

Si maintenant, nous faisons un :

docker images

Nous pouvons voir que la dépendance aspnet de .NET Core a bien été pull correctement et que notre image est bien existante (myimage).

Pour la prochaine étape, nous allons créer et exécuter notre container via notre image avec la commande :

docker run image_name

Nous pouvons observer que notre commande nous renvoie la même chaîne de caractère que nous renvoyé notre app. Si nous exécutons :

docker ps -a

Cette commande nous permet d’afficher la liste des différents containers présent sur votre poste. On peut y voir :

  • L’ID du container
  • Le nom de l’image sur lequel il est basé
  • Le point d’entrée
  • La date de création
  • Le statut
  • Le ou les ports sur lequel il est hébergé
  • Le nom du container (généré par défaut)

En l’occurrence, nous n’avons pas de port indiqué sur l’image ci-dessus, car notre application n’est pas une application Web.

Dans le cas où vous auriez une application Web et non pas une application Console comme nous. Vous pourriez tout à fait exécuter la commande suivante :

docker run -d -p 42422:80 –name container_name image_name

Elle nous renvoie, l’ID du container crée et celui-ci sera hébergé sur le port 80 pour host le port 42422.

Nous vous proposons un récapitulatif des commandes docker, dotnet et bash
ci-dessous :

Bash :

  • mkdir : Permet de créer un dossier
  • cd : Permet de se déplacer d’un dossier à l’autre
  • ls : Permet d’indiquer le contenu d’un dossier

Dotnet :

  • dotnet run : Permet d’exécuter une application .NET
  • dotnet new : Permet de créer une application
  • dotnet publish : Permet de compiler une application

Docker :

  • docker build : Permet de créer une image
  • docker images : Permet d’afficher l’ensemble des images
  • docker run : Permet de créer et d’exécuter un container
  • docker ps -a : Permet de voir l’ensemble des containers
  • docker rm : Permet de supprimer un container

Article écrit par :

  • Julie LACOGNATA <julie.lacognata@infeeny.com>
  • Pierre KORE <pierre.kore@infeeny.com>
  • Kévin ANSARD <kevin.ansard@infeeny.com>

Comprendre Docker et les architectures orientées micro-services

Prise en main

Nous avons essayé de prendre en main une solution d’architecture orientée micro-services avec Docker.

Pour cette analyse, nous nous sommes basés sur le repository suivant : https://github.com/dotnet-architecture/eShopOnContainers

Il est très complet et les explications pour l’installer sur votre poste sont suffisamment clair pour que vous puissiez lancer le projet sur vos machines. Assurez-vous d’avoir Docker d’installé et un Visual Studio ou Visual Studio Code.

Cet article relate une expérience en entreprise afin de prendre en main tout cela. Si vous rencontrez des coquilles ou des interrogations, n’hésitez pas à nous en faire part.

Projet eShopOnContainers

Sur ce, revenons-en au sujet principal : le projet eShopOnContainers.

Si vous souhaitez une meilleure compréhension des micro-services, vous avez des livres numériques à disposition dans le lien du Github. Pour les personnes qui ne seraient pas à l’aise avec l’anglais voici un lien en français résumant les points importants : https://docs.microsoft.com/fr-fr/dotnet/architecture/microservices/architect-microservice-container-applications/microservices-architecture.

Le livre a pour but d’expliquer les principes de base des architectures orientées micro-services en utilisant Docker et ses conteneurs. Le projet eShopOnContainers illustre les propos tenu dans le livre.

Les différentes étapes de notre mise en place du projet

Installation de Docker

Version Docker Desktop sur Windows Enterprise (version également valable pour Windows Pro mais pas pour la version Classic)

Pour toutes les personnes qui installent Docker pour la première fois, les étapes se font facilement et sans encombre, il vous faudra créer un compte sur le site officiel de Docker (https://www.docker.com/) afin d’avoir un DockerID.

  • Les problèmes rencontrés

Un problème peut parfois arriver lorsque vous avez une version de Docker ultérieure à cette version 18.06.0-ce-win70 et que vous essayez de la mettre à jour vers la version actuelle Docker Desktop Community 2.2.0.0.

En effet, il y a des résidus de l’ancienne version qui empêche de mettre à jour la version de Docker.

  • La solution

Pour résoudre ce problème de mise à jour de version de Docker, il existe un script PowerShell que vous trouverez ci-dessous :

Il faut enregistrer ce fichier sous format .ps1 et le l’exécuter avec une fenêtre PowerShell en mode administrateur !

$ErrorActionPreference = « SilentlyContinue » kill -force -processname ‘Docker for Windows’, com.docker.db, vpnkit, com.docker.proxy, com.docker.9pdb, moby-diag-dl, dockerd try { ./MobyLinux.ps1 -Destroy } Catch {} $service = Get-WmiObject -Class Win32_Service -Filter « Name=’com.docker.service' » if ($service) { $service.StopService() } if ($service) { $service.Delete() } Start-Sleep -s 5 Remove-Item -Recurse -Force « ~/AppData/Local/Docker » Remove-Item -Recurse -Force « ~/AppData/Roaming/Docker » if (Test-Path « C:\ProgramData\Docker ») { takeown.exe /F « C:\ProgramData\Docker » /R /A /D Y } if (Test-Path « C:\ProgramData\Docker ») { icacls « C:\ProgramData\Docker\ » /T /C /grant Administrators:F } Remove-Item -Recurse -Force « C:\ProgramData\Docker » Remove-Item -Recurse -Force « C:\Program Files\Docker » Remove-Item -Recurse -Force « C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Docker » Remove-Item -Force « C:\Users\Public\Desktop\Docker for Windows.lnk » Get-ChildItem HKLM:\software\microsoft\windows\currentversion\uninstall | % {Get-ItemProperty $_.PSPath} | ? { $_.DisplayName -eq « Docker » } | Remove-Item -Recurse -Force Get-ChildItem HKLM:\software\classes\installer\products | % {Get-ItemProperty $_.pspath} | ? { $_.ProductName -eq « Docker » } | Remove-Item -Recurse -Force Get-Item ‘HKLM:\software\Docker Inc.’ | Remove-Item -Recurse -Force Get-ItemProperty HKCU:\software\microsoft\windows\currentversion\Run -name « Docker for Windows » | Remove-Item -Recurse -Force #Get-ItemProperty HKCU:\software\microsoft\windows\currentversion\UFH\SHC | ForEach-Object {Get-ItemProperty $_.PSPath} | Where-Object { $_.ToString().Contains(« Docker for Windows.exe ») } | Remove-Item -Recurse -Force $_.PSPath #Get-ItemProperty HKCU:\software\microsoft\windows\currentversion\UFH\SHC | Where-Object { $(Get-ItemPropertyValue $_) -Contains « Docker » }

Une fois le script enregistré, pour le lancer il vous suffit de lancer la commande dans le dossier où vous avez enregistrer le script suivante dans votre PowerShell :

.\[nom de fichier].ps1

Que permet-il ? De retirer tous les résidus présent sur votre poste de travail.

Une fois le script terminé, vous pouvez relancer l’installation de Docker Desktop sur votre machine.

Cloner le repository eShopOnContainers

Pour se faire, rendez-vous sur le lien se trouvant plus haut et ouvrir un cmd ou une fenêtre Powershell dans le répertoire souhaité puis exécuter la commande suivante :

git clone https://github.com/dotnet-architecture/eShopOnContainers.git

Configurer votre réseau

Lors de l’étape de configuration de votre réseau, nous vous conseillons (au cas où le script add-firewall-rules-for-sts-auth-thru-docker.ps1 ne fonctionne pas immédiatement au lancement et vous indique une erreur) de vérifier la sécurité de votre PC. Pour pouvoir y accéder, ouvrez votre fenêtre PowerShell en mode administrateur dans le répertoire de votre projet et plus exactement dans :

C:\votre_repertoire\eShopOnContainers\deploy\windows

Et exécutez la commande suivante :

> Get-ExecutionPolicy

Cela va vous indiquer le mode dans lequel vous êtes entre

  • Restricted
  • AllSigned
  • RemoteSigned
  • Unrestricted

Ensuite pour modifier cette restriction, taper et exécuter la commande suivante :

>Set-ExecutionPolicy RemoteSigned

Le mode RemoteSigned permet d’autoriser l’exécution de script locaux. Nous vous conseillons de remettre après avoir lancer le script .ps1 de remettre la protection initiale de votre PC pour éviter toutes erreurs possible par la suite.

Builder le projet

Toujours avec votre fenêtre PowerShell revenir sur src\ et lancer un

docker-compose build

Cette étape prend un peu de temps (entre 10 à 30 minutes selon les pc et la connexion)

Une fois cette étape terminée, lancer la commande

docker-compose up

Elle va vous permettre d’instancier les différents micro-services du projet.

Chaque services dans la solution possédant son propre Dockerfile, le fait de lancer un docker-compose permet d’indiquer qu’on lance l’entièreté du projet afin de lancer l’exécution de tous les micro-services.

Vous pouvez lancer l’adresse suivante : localhost:5107 qui vous permettra de connaitre l’état de vos micro-services (si tout s’est bien passé, tout devrait apparaitre vert et vous pourrez en parallèle ouvrir le site web sous l’adresse localhost:5100 et voir le eShopOnContainers Catalog.

Fichier docker.compose.yml ?

Docker compose est un outil  de gestion de package Docker. Cet outil va lancer vos conteneurs et leurs éventuels liens à partir d’un fichier de configuration écrit en yaml.

Il permet la gestion de plusieurs conteneurs et leurs communication grâce a un fichier docker-compose.yml

Exemple d’un fichier docker.compose.yml

Pour aller plus loin

Hello World – Docker

Ouvrir une fenêtre PowerShell et lancer la commande :

docker run hello-world

Celle-ci va télécharger l’image, la build et la run et vous obtiendrez :

Qu’est-ce qu’un Dockerfile ?

Un Dockerfile est “un fichier texte qui contient des instructions sur la façon de construire une image Docker. C’est comme un script batch” (cf. le livre Containerized Docker Application Lifecycle with Microsoft Platform and tools book).

Le principal avantage de ce fichier est qu’il facilite la reproductibilité de la création des images.

Comme vous pouvez le voir ci-dessus, voici la composition d’un Dockerfile.

Comment ça marche ?

  • FROM : Permet de définir une image de base sur laquelle construire notre image. Par exemple la première ligne de la capture d’écran va récupérer l’image aspnet:3.1-nanoservier-1903 (version 3.1 d’ASP .NET Core) sur lequel va tourner notre container.
  • WORKDIR : Définit le dossier dans lequel l’installation des packages va être fait, il se fait sur le daemon.
  • EXPOSE : Sert à définir le ou les port(s) exposé(s) par notre container.
  • COPY : Copie les fichiers de notre répertoire vers le WORKDIR définit.
  • RUN : Permet de build notre image.
  • ENTRYPOINT : Correspond au point d’entrée pour lancer notre application

Docker Engine (daemon)

Afin d’orchestrer les différents conteneurs. Docker est doté d’un service de type client-serveur qui permet la communication entre l’utilisateur et un service nommé Docker Engine.

Docker Engine est une Api RESTful qui se charge de construire et exécuter les conteneurs. Le Client est un exécutable permettant (via une invite de commande la plupart du temps) d’envoyer des instructions à un daemon faisant tourner Docker Engine.

On notera qu’il est tout à fait possible d’interroger le daemon docker autrement qu’avec le client. (Utilisation de requête Curl par exemple).

Les images Docker

Une image est un ensemble de fichier en lecture seul archivé au format .tar :

  • Version : contenant la version de l’image.
  • Json : contenant un grand nombre de métadonnée (ex : id de l’image, référencement des images utilisées).
  • tar : archive contenant le système de fichier de l’image

Elles sont une représentation statique d’une application ou d’un service, de leurs configurations ou et de leurs dépendances. Un conteneur n’est donc rien d’autres que l’instanciation d’une image Docker.

L’une des forces des images Docker, est qu’elles peuvent être composé d’une ou plusieurs autres images en les référençant. Cela revient à créer une archive englobant tous les fichiers contenus par les images sous-jacent. Elle bénéficie ainsi de l’ensemble du système de fichier de celles-ci lors de son instanciation en conteneurs, évitant ainsi astucieusement les redondances.

Qu’est-ce que ça nous a appris ?

De faire la différence entre une application monolithique et une application orientée micro-services.

Application monolithique

L’application monolithique est simple en terme de conception (beaucoup plus simple à comprendre également)

Il peut convenir au petit projet, mais dès lors que le projet change pour intégrer plus de complexité, il peut s’avérer limité.
pourquoi ?

  • A cause de sa scalabilité -> on s’explique, lorsque vous souhaitez agrandir votre projet à cause d’un goulot d’étranglement, il est tout à fait possible d’agrandir toute l’application. Cependant dans la plupart des cas il n’y a qu’une partie de l’application qui nécessite une mise à l’échelle. Ce qui entraîne un gaspillage des ressources non négligeable.
  • Le déploiement : Dans ce type d’application, lorsqu’une modification est apporté à une partie de l’application c’est l’ensemble qui va être déployé.

Application orientée micro-services

L’application orientée micro-services est complexe en terme de compréhension, mais apporte de nombreux avantages. Chaque services étant indépendant les uns des autres, ils peuvent être réutilisés pour divers projet.

Si demain, on veut récupérer un service de paiement, il est tout à fait possible de le récupérer et de remplacer celui existant par le nouveau (on parle alors d’interopérabilité du service).

  • Il est possible de scaler un service en particulier
  • Grâce à l’isolation permis par Docker, il est possible d’installer un environnement spécifique pour chaque service
  • Facilite grandement le déploiement et la mise à jour des services

Les bases de Docker

Nous avons également pris en main les bases de Docker et vu les principes de conteneur et de conteneurisation.

Article écrit par :

  • Julie LACOGNATA <julie.lacognata@infeeny.com>
  • Pierre KORE <pierre.kore@infeeny.com>
  • Kévin ANSARD <kevin.ansard@infeeny.com>

Liste des packages R sur MLServices

En avril 2015, Microsoft rachetait la société Revolution Analytics pour intégrer sa solution RRE au serveur de bases de données SQL Server. En plus des trois services historiques (Integration Services, Analysis Services, Reporting Services), est donc apparu R Services dans la version 2016 de SQL Server. Un an plus tard, pour la sortie de SQL Server 2017, le service est rebaptisé Machine Learning Services et intègre maintenant le langage Python.

Les deux langages phares de l’Open Source pour la Data Science partagent la notion de packages, c’est-à-dire de libraires apportant des fonctionnalités complémentaires et souvent indispensables.

Ainsi les packages R s’installent avec la ligne de commande :

 install.packages("nomPackage")

Il est maintenant possible de jouer le code R au plus près des données (« in Database Analytics ») en l’encapsulant dans un script T-SQL.

Mais l’appel aux librairies spécifiques est conditionné… par leur présence sur le serveur !

Voici un script qui permet d’obtenir la liste des packages présents sur le serveur hébergeant ML Services :

EXEC sp_execute_external_script
@language = N'R'
, @script = N'
pkg_list = data.frame(installed.packages()[,c(1,3,5,16,2)])
'
, @output_data_1_name = N'pkg_list'
WITH RESULT SETS ((
Package nvarchar(200)
,Version nvarchar(200)
,Depends nvarchar(200)
,Built nvarchar(200)
,LibPath nvarchar(200)
));

Et ci-dessous, un exemple de résultat :

ML Services - pkg du serveur

Paul PETON, Microsoft MVP Artificial Intelligence

 

 

 

 

 

 

 

Mise en place d’une architecture Lambda avec Power BI et Logic Apps

Par Nidhal BRIBECH, de la practice Data Experience

  1.     Introduction

 A travers ce tutoriel, nous allons mettre en place une architecture Lambda à l’aide des outils Microsoft à la fois sur le cloud et en local.

L’architecture Lambda permet de stocker et de traiter de larges volumes de données (batch) tout en intégrant les données les plus récentes dans un flux de streaming.

Pour nous rapprocher de cette architecture, j’ai choisi d’utiliser le service Microsoft Azure « Logic App » permettant de récupérer les données sous forme de batch et Power BI en ligne pour la partie donnée en temps réel.    

 2.     Scénario

 Nous souhaitons stocker les tweets provenant des médias français présent sur Twitter à la fois sous forme de fichiers csv dans un blob storage que l’on pourra exploiter une fois que l’on a une volumétrie importante. Mais aussi agrémenter une solution Power BI en ligne qui permettra d’étudier les tweets les plus récents (par exemple tendances des tweets du mois présent).

 3.     Architecture

                                 

 4.     Pré requis

 Créer un compte Twitter pour accéder aux données fourni par l’API (https://twitter.com/).

Installer Power BI Desktop (disponible gratuitement à l’adresse suivante : https://powerbi.microsoft.com/fr-fr/desktop/).

Avoir un compte Power BI (Choisir « partage et collaboration dans le cloud » https://powerbi.microsoft.com/fr-fr/get-started/).

Avoir un compte Azure (Compte gratuit avec 170€ de crédit https://azure.microsoft.com/fr-fr/).

 5.     Créer un blob Storage

 La première étape consiste à créer un blob storage pour stocker les tweets qui remplissent nos critères. Ce type de stockage enregistrera nos données sous la forme de fichiers textes.

 

 

 On renseigne son nom, son type, l’endroit où il se trouve et on renseigne une ressource group (sinon on la crée en même temps que le blob storage en cochant « Create New »).

 On aura besoin de la clé (key1) et du nom (Storage account name) pour la partie Power BI desktop, donc on les garde dans un fichier texte.

 

 

 Par la suite, on crée un container qui va recevoir nos tweets à la manière d’un dossier.

 6.     Créer un Logic Apps

 La logic app va permettre d’exécuter automatiquement un processus qui récupèrera les tweets selon des critères spécifiques, à une fréquence prédéfinie et selon un enchaînement d’opérations.

On renseigne son nom, la ressource groupe (la même que celle du blob storage) ainsi que sa localité.

En cliquant sur Logic App Designer, nous arrivons sur l’interface graphique. Une multitude de triggers (déclencheurs) sont disponibles mais celui qui nous intéresse est « When a new tweet is posted ».

 On se connecte à l’aide de nos identifiants Twitter pour permettre la connexion entre les flux Twitter et la logic app.

 

 On définit les filtres de recherche et l’intervalle entre chaque exécution (dans notre exemple, il s’agit de tweets provenant de comptes d’actualités en France que l’on recherche toutes les 5 minutes).

 Nous récupérons les tweets grâce à ce trigger et allons les traiter avec deux actions.

On crée une action à la suite du trigger (cliquer sur Add an action).

Et nous allons choisir Azure Blob Storage.

Plus précisément l’action « Create blob » pour stocker chaque tweet en fichier unique.

On établit une connexion avec notre container préalablement crée en renseignant un nom de connexion (au choix) puis en sélectionnant le blob storage correspondant :

Une fois la connexion établit, on renseigne le container de réception, le nom des blobs et le contenue des blobs.

Blob name prend comme nom la date au moment de la création du blob suivi de l’extension « .txt » pour que le fichier soit exploitable (on verra cela par la suite sur Power BI).

concat(utcNow(),'.txt')

 Blob content contiendra les éléments que nous souhaitons garder (User Name, CreatedAt et Tweet Text) et on les sépare à l’aide d’un point-virgule pour mieux les délimiter.

concat(triggerBody()?['UserDetails']?['FullName'],';',
triggerBody()?['CreatedAtIso'],';',triggerBody()?['TweetText'])

 

En parallèle à cela, nous allons ajouter une action qui permettra de charger les données dans un tableau de bord Power BI en ligne (service cloud).

Mais avant cela il faut créer un jeu de données sur son espace de travail en ligne (https://app.powerbi.com/).

 Une fois créé, cliquez sur « Créer » en haut à droite, puis sélectionnez « Jeu de données de streaming ».

 

 Il faut choisir « API ».

 

Ensuite, on renseigne les valeurs que l’on souhaite extraire des tweets (TweetText, UserName, CreatedAt).

 Pour cela on renseigne un nom de jeu de données et pour chaque valeur un nom et un type.

On valide la création puis cliquez sur « Terminé ».

 Maintenant que nous avons un jeu de données en ligne, il faut l’agrémenter d’éléments. Donc on retourne sur notre logic app et on ajoute une action en parallèle du blob storage.

 Recherchez Power BI puis sélectionnez l’icône correspondante.

Puis on choisit l’action « Add rows to a dataset » qui va permettre d’ajouter les valeurs à notre jeu de données en streaming.

On renseigne :

·        Le workplace, le dataset et la table de notre application Power BI en ligne.

·        Les valeurs pour les colonnes de notre table à agrémenter.

Sauvegardez en cliquant sur Save puis lancez la logic app (Run). Il faut que les comptes en écoute tweetent pour démarrer le processus automatiquement.

 

Suite à l’exécution nous avons confirmation du bon déroulement des actions.

En retournant sur le container, nous retrouvons les fichiers créés.

Et en allant sur Power BI dans le cloud, on retrouve aussi les données des tweets.

 En sélectionnant la visualisation Table puis en cochant les divers champs, on retrouve les tweets stockés depuis la première itération du Logic App. On pourrait ajouter un filtre afin de n’afficher que les tweets du mois en cours pour faire une analyse en temps réel.

 

7.     Exploitation sur Power BI desktop.

 Pour récupérer les fichiers et les exploiter sur Power BI desktop, on procède d’abord en ajoutant les données via le cloud « Azure ». Obtenir les données -> Plus.

On choisit « Stockage Blob Azure ».

 On renseigne les informations de connexion concernant notre blob storage (blob storage -> Access keys).

On renseigne la clé (key1), puis se connecter.

 

En cochant sur le container « tweets », on retrouve tous les fichiers blob créés (si rien ne s’affiche cliquez sur le bouton de rafraîchissement en haut à droite).

Puis chargez les en cliquant sur « Charger ».

Vous verrez qu’une table a été créée avec plusieurs champs. Cliquez sur « Modifier les requêtes », à partir du menu Accueil.

Nous retrouvons nos éléments, cependant il est nécessaire de les extraire pour en tirer les informations que l’on a concaténées.

Pour cela, il faut faire clic droit sur la colonne « Content » puis choisir Transformer -> Texte.

 On trouve les éléments mit à la suite et bien séparé de points-virgules. On peut ainsi transformer cette colonne en plusieurs données exploitables. Clic droit sur la colonne « Content » puis Fractionner la colonne -> Par délimiteur.

 On choisit les paramètres ci-dessous :

·        Délimiteur : Point-virgule.

·        Fractionner à : Chaque occurrence du délimiteur.

 On a bien les colonnes correspondantes aux éléments des tweets que l’on a souhaité garder, on peut changer le nom des colonnes pour plus de clarté.

Si une 4ème colonne sans données est créée, il suffit de la supprimer (clic droit sur la colonne, supprimer).

 

Voici les tweets que l’on a enregistré depuis le début du processus. On pourra faire une analyse une fois le volume de données devenu très important.

 

8.     Conclusion

 En suivant ce tutoriel, on retrouve une architecture lambda, d’un côté Power BI desktop avec les données stockées dans un blob storage, de l’autre Power BI Cloud avec les données les plus récentes et en temps réels.

Ainsi on peut choisir des axes d’analyses variés pour représenter l’information et le sens que nos données fournissent.

Cependant, cette architecture peut poser un problème car chaque tweet est stocké deux fois (fichier blob et ligne dans le cloud Power BI) ce qui pourrait s’avérer couteux en stockage avec une volumétrie de données importante.

Azure Machine Learning Workbench : première prise en main

Par Amar ADGHAR, consultant Data Experience

Introduction

Le but d’Azure Machine Learning est d’analyser des données, puis de développer et d’implémenter des modèles statistiques à l’aide de différents outils.

L’un de ces outils se nomme Azure Machine Learning Workbench. Il est constitué d’une application de bureau (cela s’apparente à Power BI Desktop) ainsi que d’outils en ligne de commande. Il vous permet de gérer des solutions d’apprentissage automatique dans l’intégralité du cycle de vie des sciences des données.

Pour l’installation, on peut suivre le tutorial suivant :

https://docs.microsoft.com/fr-fr/azure/machine-learning/preview/quickstart-installation

Remarque : Lors de la création du service Azure Machine Learning Expérimentation. Il est impératif que notre espace de stockage soit dans la même région que ce dernier.

Ingestion et préparation des données

 

On commence par créer un nouveau projet. Pour cela, il suffit de cliquer sur la croix et d’appuyer sur new project comme représenté ci-dessous :

Par la suite, on renseigne le nom du projet. On peut sauvegarder ce dernier et faire du versionning dans un Repo Git si on le souhaite. Dans le search Project Templates, nous disposons de plusieurs types de projet préprogrammer, nous avons un exemple connu : le projet Iris. Dans notre cas, nous allons choisir blank project.

Après avoir créé notre projet, on va charger un fichier CSV à partir d’un répertoire local. On se positionne sur l’onglet vue de données :

On clique sur la croix en haut à gauche puis sur add a datasource :

Par la suite, nous chargeons notre fichier en déroulant les étapes indiquées sur la fenêtre (on dispose de 6 étapes). Dans l’étape 3 par exemple, on peut avoir une première visualisation de notre fichier et décider du séparateur de colonne…etc. L’étape 4 nous permet d’observer le type de données dont on dispose et de pouvoir changer ce type si l’on souhaite. Une fois les étapes terminées, on peut cliquer sur finish, ce qui nous donne :

 

Le bouton Metrics (en bleu dans l’image ci-dessus), nous permet de visualiser les statistiques descriptives des colonnes de notre fichier :

Après avoir observé ces dernières, on peut se pencher sur la préparation de nos données pour notre modèle. En appuyant sur l’icône Data, on revient à notre tableau de données. il nous suffit de cliquer sur prepare et new data prepare package et nommer ce dernier :

On voit ainsi, dans la partie data préparation, un nouveau package prêt à être transformer et nettoyer :

En cliquant droit sur une colonne, on trouve différentes fonctionnalités. Cette partie est similaire à la partie préparation de données dans Power BI. Une alternative existe, il s’agit de passer via le langage python.

Développement des modèles et gestion des expérimentations

Une fois nos données prêtent, on peut développer notre modèle. Il suffit de cliquer droit sur notre dataset dans le volet data preparation et re- cliquer sur generate acces data file, ce qui nous créer automatiquement une page de code Python :

De l’image, on peut remarquer que cela nous créer un onglet .py et automatiquement notre dataframe. On peut générer notre code python. On peut aussi créer un jupyter notebook pour tester notre code. On va sur l’icône qui représente un livre, on clique sur plus et on nomme notre notebook :

Remarque : On peut aussi le faire en cliquant droit sur prepare data. Cela nous crée bien un notebook jupyter. Cependant, on ne peut pas tester notre code.

Une fois qu’on a vérifié que notre code fonctionne, on peut le rajouter dans fenêtre. Afin de compiler ce dernier, on appuie sur le bouton RUN :

On peut observer à droite qu’une fenêtre nommer Jobs s’ouvre et on observer que note code est en train de s’exécuter.

Remarque : On peut observer aussi qu’on a un onglet se nommant Arguments. On trouve son utilité avec les variables sys.arg dans Python. Il peut être utiliser pour une régression logistique par exemple.

On peut s’amuser à relancer et changer la valeur de nos variables (Arguments par exemple). Une fois qu’on l’a exécuté (plusieurs fois). On peut cliquer sur l’historique (carré rouge dans l’image ci-dessous) et observer quelques metrics sur ce dernier :

On peut aussi filtrer sur une exécution. Cela va nous permettre de tester les différents temps d’exécution de notre programme et d’affiner ce dernier par la suite.

Déploiement des modèles dans différents environnements cibles

Afin de réaliser le déploiement, dans un premier temps, on va exécuter notre script dans un environnement local, ce qui va nous générer un fichier JSON qui va capturer le schéma d’entrée de données requis par le modèle. Une fois cela fait, on va récupérer notre fichier JSON et un fichier du modèle se nommant model.pkl qui aura été enregistré dans notre répertoire du projet :

A l’aide d’une commande, on va créer un environnement local et enregistrer les fichiers récupérer au pare avant dans ce dernier. Cela va nous permettre de créer notre service web en temps réel. Pour réaliser cela, il nous suffit de taper la commande suivante :

az ml service create realtime -f mtcars prepare.py –model-file model.pkl -s service_schema.json -n irisapp -r python –collect-model-data true -c aml_config\conda_dependencies.yml

Cette commande génère un ID du service Web qu’on pourra utiliser plus tard.

Remarque : Le nom du service doit être en minuscule.

Lorsque vous exécutez la commande, le modèle et le fichier de notation sont chargés sur le compte de stockage que vous avez créé lors de la configuration de l’environnement. Le processus de déploiement crée une image Docker contenant le fichier de modèle, de schéma et de notation, puis la place dans le registre de conteneurs Azure : <ACR_name>.azureacr.io/<imagename>:<version>.

La commande extrait l’image localement sur votre ordinateur, à partir de laquelle il démarre un conteneur Docker. Dans le cadre du déploiement, un point de terminaison HTTP REST pour le service web est créé sur votre machine locale. Après quelques minutes, la commande doit se terminer avec un message de réussite, votre service web est alors opérationnel.

Conclusion

Cette outil représente un bon environnement pour commencer à faire des analyses statistiques et des modèles prédictifs. Cependant, il reste assez limité pour l’instant, par exemple, on ne peut utiliser qu’une seule version de Python et les packages disponibles (on peut télécharger de nouveau packages mais cela risque de poser problème lors du déploiement vers Azure étant donné la version dont on dispose). A ce jour, nos projets sont restreints à 25Mo si la taille de nos fichiers sont volumineux. Il existe bien sûr des solutions alternatives sous certaines conditions :

https://docs.microsoft.com/fr-fr/azure/machine-learning/preview/how-to-read-write-files

Nous suivrons le développement de cette offre très prometteuse, actuellement en préversion, dans de prochains articles.

Article rédigé par Amar ADGHAR

 

Débutez instantanément un projet avec la Data Science Virtual Machine

Par Paul PETON, lead data scientist

Le cloud Azure est un espace qui permet de créer des machines virtuelles (VM) pour tout besoin d’Infrastructure as as Service (IaaS). Il existe aujourd’hui une déclinaison spécifique d’une machine virtuelle dédiée aux Sciences de Données : la Data Science Virtual Machine (DSVM).

Sa création se fait en quelques minutes sous un compte Azure.

 

Une fois la VM déployée et démarrée, on utilise le principe de connexion de bureau à distance.

Une boîte à outils toute prête

Cette VM possède l’atout majeur d’être préconfigurée avec la plupart des applications de la boîte à outils des Data Scientists. Passons les principaux outils en revue :

  • SQL Server 2017 Developer Edition : le serveur de bases de données relationnelles est préconfiguré sur la VM et contient déjà une base de données de test (les fameux taxis new-yorkais). Il n’y a pas à se poser de question de licence ou de paramétrage. Depuis sa version 2017, SQL Server dispose d’un quatrième service nommé ML Services qui permet d’exécuter du code R ou Python encapsulé dans un script T-SQL.

  • Microsoft ML Server Developer Edition : il s’agit de la version autonome de ML Services, indépendante de l’installation de SQL Server. Il sera alors par exemple possible de travailler avec le format de fichier optimisé pour le travail par « chunck » et en mémoire : XDF.
  • Visual Studio Community Edition : l’interface préférée des développeurs qui baignent dans l’univers Microsoft
  • Jupyter notebook (avec noyaux R, Python, PySpark) : les notebooks sont des interfaces web qui permettent d’exécuter du code à la volée et de visualiser les résultats de manière intermédiaire entre les blocs d’instructions. En quelques années, les notebooks se sont imposés comme la présentation la plus claire d’un code et de ses résultats. Leur force réside également dans leur capacité à exécuter un grand nombre de langages.

A la première utilisation, il faut définir un nouveau mot de passe puis redémarrer le service.

Sur Windows, se connecter à la page https://localhost:9999

Sur Linux, se connecter à la page https://localhost:8000

Ajouter ensuite une exception de sécurité dans le navigateur.

Le notebook est alors accessible et présente de nombreux exemples de codes.

  • Power BI Desktop : on ne présente plus l’outil de BI Self Service de Microsoft qui permet de réaliser très rapidement des transformations puis une exploration des données. On ne l’utilisera toutefois pas ici pour sa capacité à diffuser et partager des tableaux de bord.
  • Azure Machine Learning Workbench : le nouvel outil dédié au Machine Learning de Microsoft est sorti en préversion depuis septembre 2017. Pour l’instant, il présente surtout une interface graphique très efficace pour la préparation des données. A termes, il servira de plateforme pour le déploiement et l’exécution de modèles sur un environnement Docker, éventuellement couplé à Spark. Nous traiterons de ce produit dans un prochain article.
  • Instance autonome Spark pour le développement local et le test

Citons également la distribution Anaconda de Python, JuliaPro et quantités de librairies R et Python dédiées au Machine Learning.

Bien sûr, il reste possible d’ajouter d’autres applications puisque nous travaillons ici avec une machine virtuelle.

Des configurations différentes à disposition

Le premier choix à effectuer face à l’offre des DSVM est celui du système d’exploitation : Windows 2012, Windows 2016 mais aussi Linux Ubuntu. Pour ce dernier, l’accès pourra se faire par connexion SSH mais aussi en lançant un bureau plus visuel au moyen du client X2Go.

Ensuite, se posera la question du dimensionnement de la VM. Les configurations varient légèrement selon le système d’exploitation. On jouera ici sur le type de disque pris en charge (SSD ou HDD), le nombre de processeurs virtuels (de 1 à 32) et la mémoire vive (jusqu’à 448 Go !)

La tarification évoluera en fonction de la configuration choisie et pour ces configurations comparables, il semble que la version Linux soit moins chère. Comme dans de nombreux services Azure, le coût s’évalue à l’heure d’utilisation. Il sera donc prudent d’enclencher l’arrêt automatique quotidien à une heure donnée. Le redémarrage reste quant à lui manuel.

Convaincu.e.s par la simplicité de déploiement de la DSVM ? Quel sera votre prochain projet de Data Science qui trouvera là son parfait terrain de jeu ?

Une variante pour le Deep Learning

Le Deep Learning est une évolution des réseaux de neurones, au cœur des méthodes d’apprentissage automatique, qui fait grand bruit par ses succès actuels, particulièrement dans la reconnaissance d’images. De nombreux frameworks existent pour « l’apprentissage profond » qui nécessitera des ressources importantes pour le calcul : Microsoft Cognitive Toolkit, TensorFlow, Keras, Theano, Caffe2, Chainer, Deep Water (H2O), etc. Il sera donc nécessaire de faire appel à la puissance des GPU et ce sont donc des VM spécifiques (mais plus chères) qui sont associées à ce besoin.

Nous traiterons du Deep Learning et de la DLVM dans un prochain article.

Paul PETON – Lead Data Scientist

Réaliser un clustering des clients avec Azure Data Factory et Azure Machine Learning Studio

Contexte

Dans cet article, nous allons segmenter une base de données clients pour créer des sous-ensembles de clients difficiles à identifier à l’œil nu, en utilisant l’algorithme de clustering K-Means. Cela peut aider le service Marketing à cibler un groupe spécifique de clients.

Le clustering, est une méthode d’apprentissage automatique non supervisée, qui consiste à séparer des données, en constituant des groupes homogènes. Le but est de minimiser la distance entre les observations du même groupe et de maximiser la distance entre les groupes.

Pour réaliser ce clustering, nous allons utiliser le service Azure Data Factory et nous avons besoin de créer un service web sous Azure Machine Learning Studio.

Azure Data Factory

(voir présentation de l’outil)

Azure Data Factory est un service d’intégration de données dans le cloud Microsoft Azure, qui gère et automatise le déplacement et la transformation des données. Pour cet article, nous avons utilisé la version 1 de Azure Data Factory.

Une Azure Data Factory est composée de :

  • Services liés
  • Jeux de données
  • Pipeline
  • Activité

Azure Machine Learning Studio

(voir présentation de l’outil)

Azure Machine Learning Studio est un service qui permet de générer, tester et déployer des solutions d’analyses prédictives.

Pour mettre en place cette solution, il y a deux grandes étapes à réaliser :

  1. Azure Machine Learning: Déployer le modèle de clustering des clients
  2. Azure Data Factory: Consommer le Web Service Azure Machine Learning

Azure Machine Learning: Déployer le modèle de clustering des clients

Dans Machine Learning Studio, nous créons une expérience qui exécute un script R appelant la méthode de clustering K-Means.

Nous avons publié notre expérience comme un service web Azure. Nous pouvons dès à présent envoyer des données à notre modèle via les points de terminaison de service web et recevoir des prédictions de résultats pour le modèle.

Pic01

Voici le résultat du déploiement de l’expérience en tant que service web :

Pic02.png

On aura besoin de ces deux informations : API KEY et Batch URI dans l’étape suivante.

Pic03

Azure Data Factory: Consommer le Web Service Azure Machine Learning

Notre Azure Data Factory va :

  • obtenir le fichier CSV qui contient la liste des clients,
  • ensuite appeler l’API d’exécution par lot Azure Machine Learning
  • et enfin copier le résultat d’exécution dans le compte Azure Storage sous forme d’un fichier CSV.

Le diagramme suivant illustre les différents composants de notre Data Factory.

Pic04

C’est le pipeline PredictivePipeline qui invoquera le modèle Azure Machine Learning. Pour cet article, on utilise Azure Blob Storage pour stocker les données d’entrée et de sortie.

 La création de notre Azure Data Factory se résume en 5 étapes :

  • 1- Création du service liépour le compte Azure Storage. On va utiliser le même compte de stockage pour les données d’entrées et de sortie, pour cela on va créer un seul service lié en fournissant la chaine de connexion de notre compte de Stockage.

Pic05

  • 2- Création du jeu de données d’entrée : ClientClusteringInputBlob

Pic06

Le jeu de données est un fichier plat déposé sur le blob storage.

Pic07.png

  • 3- Création du jeu de données de sortie : ClientClusteringResultBlob

Pic08

  • 4- Création d’un service liéde type AzureMLLinkedService en fournissant la clé API et l’URL d’exécution par lots du modèle.

Pic09

On précise ici l’URL du point de terminaison (mlEnpoint ) et la clé de l’API.

Pic10.png

  • 5- La dernière étape est la créationdu pipeline contenant une activité de type AzureMLBatchExecution, qui va utiliser le Batch URI et l’API Key de notre Service Web. Un pipeline peut enchainer plusieurs activités.

Le mlEndpoint correspond à la méthode POST du batch.

Pic11.png

Récupérer le code sur la page :

https://docs.microsoft.com/en-us/azure/data-factory/v1/data-factory-azure-ml-batch-execution-activity

Modifier inputs, outputs et linkedservicename, web service input et output.

Voici notre pipeline PredictivePipeline :

Pic12.png

On a ici choisi que le pipeline s’exécute tous les 3 jours.

A travers la fonctionnalité Monitor & Manage, disponible sur le Portail Azure pour la version 1 d’Azure Data Factory, on peut visualiser l’historique d’exécution (Statut, Date de début, Date de fin, Durée d’exécution …) de tous nos pipelines.

Pic13.png

Les fichiers de résultats sont stockés sur le Blob Storage.

Pic14.png

Chaque fichier contient l’association de l’identifiant du client à son segment (« cluster »).

Pic15.png

Voilà, nous avons réalisé un clustering avec le langage R en utilisant Azure Data Factory et Azure Machine Learning.

Vous pouvez effectuer régulièrement une segmentation de vos clients juste en planifiant l’exécution de la Data Factory. Vous pouvez aussi visualiser les résultats dans un outil de reporting comme Microsoft Power BI (voir présentation de l’outil) pour comprendre les comportements des clients et décrire précisément les groupes obtenus.

L’exploitation de ces données et de cet algorithme au travers de Power BI fera l’objet d’un prochain article de ce blog.

 

Article rédigé par Wafa BEN AISSA

Actus : Devices – Juin / Juillet 2017

Actus Devices

Juin-Juillet 2017

 

Au sommaire :

  • Windows 10 1703 validé pour le déploiement en Entreprise

  • Windows 10 et la fin des branches CB, CBB, LTSB

  • Windows 10 et la désactivation de VBS dans IE

  • Windows 10 et la fin des mises à jour de Build pour certains processeurs

  • Fin de support pour SCCM 2012

  • Les nouvelles possibilités fournies par SCCM 1706

  • Migrer ses GPO dans Intune

  • A la découverte de Windows Analytics ou comment exploiter la télémétrie en Entreprise

Lire la suite