Finally, in the case of applications that cannot be migrated in the coming months, there is the possibility of hosting them in Azure virtual machines, by using SQL Server template, and to benefit for an additional support extension.

In this article, we will see, depending on the situation, what are the options to continue using your applications in the best conditions of support and features.

Below, here are the 4 migration possibilities:

• On-premise migration to the 2017 version (When possible for your applications)
• Migration to SQL Database (PaaS) (When possible for your applications)
• Migration to Azure SQL Database Managed Instance, which offers nearly 100% SQL Server compatibility
• For applications that are difficult to migrate in the coming months, deploying to an Azure VM with SQL server pre-installed (via virtual machine template)

Prerequisites

In general, the migration process looks like the steps illustrated below. Even if in the end, there are many ways to execute a migration plan, it remains a project in its own:

The discovery part can be realized with MAP Toolkit:

https://docs.microsoft.com/en-us/previous-versions//bb977556(v=technet.10)

However, whatever the solution considered, it is a good idea to perform the following tasks before any migration:

On SQL Server 2008 or 2008 R2:

• Check that the last service pack is correctly installed
• Rebuild indexes (if the indexes are very fragmented)
• Check the integrity of your database with DBCC CHECKDB () (or on a copy, as this can take a long time)
• Note if the database is not linked to a maintenance plan
• Note if linked servers exist
• Note if the SQL Agent is used
• Do a full backup

On a target:

• After restoring your database, check again the integrity of your database with DBCC CHECKDB:
• DBCC_CHECKDB  WITH DATA_PURITY: https://docs.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-checkdb-transact-sql?view=sql-server-2017
• Do a DBCC UPDATEUSAGE (https://docs.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-updateusage-transact-sql?view=sql-server-2017)
• Update statistics
• Rebuild indexes
• Check the compatibility mode (be very careful, the database will use the new Cardinality Estimator introduced with SQL 2014)

   

Migrate to SQL Server 2017 (On-premise)

Here we are in a classic migration scenario. With SQL Server 2017, it is possible to either go through a backup and then restore the database or use the data Migration Assistant (DMA) tool.

In addition to the prerequisites detailed earlier in this article, on the target server that hosts SQL server 2017, check the following points:

• Use a supported operating system: https://docs.microsoft.com/en-us/sql/sql-server/install/hardware-and-software-requirements-for-installing-sql-server?view=sql-server-2017
• Check the space of the different disks (TempDB, Logs, Data)
• Recreate maintenance plans, linked servers and other SQL agents if necessary

Finally, also check the deprecated features in the SQL Server version 2017:

https://docs.microsoft.com/en-us/sql/database-engine/deprecated-database-engine-features-in-sql-server-2017?view=sql-server-2017

For the migration itself, the following methods can be used:

database backup and restore

• Since version 2017, it is possible to create a database since the backup of a database in version 2005 or higher. Detailed documentation of this feature is available on this Web page: https://docs.microsoft.com/en-us/sql/relational-databases/databases/copy-databases-with-backup-and-restore?view=sql-server-2017

Data Migration Assistant

• Data Migration Assistant (DMA) is a downloadable tool, which will be used to:
  • Do an assessment of your databases to migrate, in order to evaluate the Migration effort. A complete documentation can be found on this web page: https://docs.microsoft.com/en-us/sql/dma/dma-assesssqlonprem?view=sql-server-2017
  • Do the migration. DMA can do the migration automatically. A complete documentation of the migration process is available here: https://docs.microsoft.com/en-us/sql/dma/dma-migrateonpremsql?view=sql-server-2017

Migrate to SQL Database (PaaS)

This is another possibility of migration, and the opportunity to modernize your data infrastructure with Cloud solutions. In addition, you will benefit from all the advantages of a managed service (no hardware management, 3 copies of your data, transparent updates, elasticity, …).

Again, there are several ways to migrate your SQL Server databases to SQL database. But mainly, the 3 methods illustrated below can be used, after consulting the detailed prerequisites above. Of course, double check the prerequisites section as a first step:

• Transactional Replication: https://docs.microsoft.com/en-us/azure/sql-database/sql-database-cloud-migrate#method-2-use-transactional-replication
• Import / Export BACPAC File: https://docs.microsoft.com/en-us/azure/sql-database/sql-database-import
• Use DMA tool. Be careful, this operation will make your database inaccessible during the migration process!

In order to measure the impact of migration, it is possible to use the Database experimentation Assistant (DEA) tool. This tool allows you to capture traces, on an existing server, to be replayed on SQL Database, SQL managed instance or SQL on Linux. DEA can be downloaded here: https://www.microsoft.com/en-us/download/details.aspx?id=54090

Finally, as I mentioned earlier, there are other possible ways to migrate its databases such as using SQL Server integration Services (SSIS) or Azure Data Factory v2.

Migrate to Azure SQL Database Managed Instance (PaaS)

SQL database Managed Instance (MI) is a managed service (PaaS) that provides SQL Server compatibility close to 100%, while supporting features that are not present in SQL database such as:

• Native backup/restore function
• Linked Server
• CLR
• SQL Agent
• DB Mail (external SMTP)
• ...

In addition, SQL database MI works in its own VNet, which helps to enhance the security of your database.... But at the expense, today, of a lack of integration with, for example, other Azure services.

A complete SQL database MI overview is available on this Web page: https://docs.microsoft.com/en-us/azure/sql-database/sql-database-managed-instance#sql-features-supported

Again, after double check migration prerequisites, several ways are possible to migrate to SQL Database MI:

• Azure Database Migration Service (which will use DMA for the assessment part of the migration effort) : https://docs.microsoft.com/en-us/azure/dms/dms-overview
• Native Restore from a URL. I explained in an article, which dates a little 😊, how to do this type of backup (article in French): https://blogs.technet.microsoft.com/franmer/2013/11/15/sql-server-2014-intgration-avec-le-stockage-azure/. But this article is more up to date: https://docs.microsoft.com/en-us/sql/relational-databases/backup-restore/sql-server-backup-to-url?view=sql-server-2017

Overall the backup from a URL will follow the following path:

More details for all migration path are available here:

https://docs.microsoft.com/en-us/azure/sql-database/sql-database-managed-instance-migrate

Pay attention to the following points:

• SQL Database Managed Instance must be deployed within a virtual network. The following article gives the configuration details: https://docs.microsoft.com/en-us/azure/sql-database/sql-database-managed-instance-vnet-configuration
• The first-time creation of the service can take up to 6h. I made a test in the Central Canada region, and the first creation took about 3 hours and 17 minutes.

  

Migrate to an Azure Virtual Machine with SQL server pre-installed (IaaS)

If it is not yet possible to migrate your SQL Server 2008 databases to SQL Server 2017, and to remain covered by support, there is the ability to move your databases to a SQL Server 2008 hosted in a Azure virtual machine (VM). To do this, you can directly provision a virtual machine with SQL Server 2008 from an existing Azure VM Template. This saves time and makes sure that you have the right technology base to move your databases.

Below is an example of the models available from the Azure portal.

Once the virtual machine is provisioned from templates, it is no more or less a migration to another SQL server, with a difference anyway, it is that we will have to transfer the data to Azure, so that they are accessible by the virtual machine . Below, all possible ways to move your data bases to an Azure virtual machine with SQL Server:

• Perform on-premises backup using compression and manually copy the backup file into the Azure virtual machine
• Perform a backup to URL and restore into the Azure virtual machine from the URL
• Detach and then copy the data and log files to Azure blob storage and then attach to SQL Server in Azure VM from URL
• Convert on-premises physical machine to Hyper-V VHD, upload to Azure Blob storage, and then deploy as new VM using uploaded VHD
• Ship hard drive using Windows Import/Export Service
• If you have an AlwaysOn deployment on-premises, use the Add Azure Replica Wizard to create a replica in Azure and then failover, pointing users to the Azure database instance
• Use SQL Server transactional replication to configure the Azure SQL Server instance as a subscriber and then disable replication, pointing users to the Azure database instance

I would like to finish this article by a big thanks to Frédéric Pichaut and Nicolas Soukoff who have completed and detailed the prerequisite part, strong of their great experience with SQL Server. One MS Power! Merci!

For those who will be in Montreal, I will meet you on November 28th, 2018 at Tech Summit:https://www.microsoftevents.com/profile/web/index.cfm?PKwebID=0x1023303abcd&wt.mc_id=AID737011_QSG_SCL_276355

Franck Mercier

Enfin, dans le cas d'applications ne pouvant pas être migrées dans les prochains mois, il existe la possibilité de les héberger dans des machines virtuelles Azure, grâce aux modèles de machines embarquant directement SQL server, et de bénéficier dans ce cas d'une extension de support supplémentaire de 3 ans.

Dans cet article, nous allons voir, en fonction des situations, quelles sont les options possibles pour continuer à utiliser vos applications dans les meilleures conditions de supports et de fonctionnalités.

Ci-dessous, voici les 4 possibilités de migration :

• Migration, sur site, vers la version 2017 (Quand cela est possible pour vos applications)
• Migration vers SQL Database en mode PaaS (Quand cela est possible pour vos applications)
• Migration vers Azure SQL Database Managed Instance, qui propose une compatibilité avec SQL Server proche de 100%
• Dans le cas d'applications difficiles à migrer dans les prochains mois, déploiement dans une machine virtuelle Azure avec les modèles de machine virtuelle SQL Server 2008

Pré requis

En règle générale le processus de migration ressemble aux étapes illustrées ci-dessous. Même si au final, il existe de nombreuses manières d'exécuter un plan de migration, cela reste un projet à part entière :

La partie découverte peut se réaliser avec l'outil MAP Toolkit :

https://docs.microsoft.com/Fr-fr/previous-versions//bb977556(v=technet.10)

Cependant, quelle que soit la solution envisagée, il est de bon augure de réaliser les tâches suivantes avant toute migration :

Sur le Server SQL source :

• Vérifier que le dernier Service Pack est bien appliqué
• Reconstruire les index (si les index sont très fragmentés)
• Vérifier l'intégrité de votre base de données avec DBCC CHECKDB () (ou sur une copie, car cette opération peut prendre du temps)
• Noter si la base de données n'est pas liée à un plan de maintenance
• Noter la présence de serveurs liés
• Noter si l'agent SQL est utilisé
• Faire un backup complet

Sur la cible :

• Après restauration, vérifier à nouveau l'intégrité de votre base de données avec DBCC CHECKDB
  • Faire un DBCC_CHECKDB  WITH DATA_PURITY : https://docs.microsoft.com/fr-fr/sql/t-sql/database-console-commands/dbcc-checkdb-transact-sql?view=sql-server-2017  
• Faire un DBCC UPDATEUSAGE (https://docs.microsoft.com/fr-fr/sql/t-sql/database-console-commands/dbcc-updateusage-transact-sql?view=sql-server-2017)
• Mettre à jour les statistiques
• Reconstruire les index
• Vérifier le mode de compatibilité (faire très attention, la base de données utilisera le nouveau Cardinality Estimator introduit avec SQL 2014)

Migration vers SQL Server 2017 (sur site)

Ici, nous sommes dans un scénario classique de migration. Avec la version 2017, il est possible soit de passer par une sauvegarde puis une restauration de la base de données, soit utiliser l'outil Data Migration Assistant (DMA).

En plus des prérequis détaillés plus haut dans cet article, sur le serveur cible qui héberge SQL Server 2017 :

• Utiliser un système d'exploitation compatible : https://docs.microsoft.com/fr-fr/sql/sql-server/install/hardware-and-software-requirements-for-installing-sql-server?view=sql-server-2017
• Vérifier l'espace des différents disques (TempDB, Logs, Data)
• Recréer les plans de maintenance, les serveurs liés et autres agents SQL si besoin

Enfin, vérifiez aussi les fonctionnalités dépréciées dans la version SQL Server 2017 : https://docs.microsoft.com/fr-fr/sql/database-engine/deprecated-database-engine-features-in-sql-server-2017?view=sql-server-2017

En ce qui concerne la migration elle-même, il est possible d'utiliser les méthodes suivantes:

Sauvegarde et restauration des bases de données

• Depuis la version 2017, il est possible de créer une base de données depuis la sauvegarde d'une base en version 2005 ou supérieure. La documentation détaillée de cette fonctionnalité est disponible sur cette page web : https://docs.microsoft.com/fr-fr/sql/relational-databases/databases/copy-databases-with-backup-and-restore?view=sql-server-2017

Data Migration Assistant

• Data Migration Assistant (DMA) est un outil téléchargeable ici, qui va vous servir à :
  • Faire une évaluation de vos bases de données à migrer, afin d'évaluer l'effort de migration. Une documentation complète se trouve sur cette page web : https://docs.microsoft.com/fr-fr/sql/dma/dma-assesssqlonprem?view=sql-server-2017
  • Faire la migration. DMA peut faire la migration de manière automatique. Une documentation complète du process de migration est disponible ici : https://docs.microsoft.com/fr-fr/sql/dma/dma-migrateonpremsql?view=sql-server-2017

Migration vers SQL Database (PaaS)

C'est une autre possibilité de migration, et aussi l'occasion de moderniser votre infrastructure de donnée avec les solutions Cloud. De plus, vous bénéficierez de tous les avantages d'un service managé (Pas de gestion de matériel, données répliquées en 3 exemplaires, gestion des mises à jour transparentes, élasticité, ….).

Encore une fois, il existe plusieurs méthodes pour migrer vos bases SQL vers SQL Database. Mais principalement, les 3 méthodes illustrées ci-dessous peuvent être utilisées, après avoir consulté les prérequis détaillés plus haut :

• Réplication transactionnelle. Une documentation se trouve ici : https://docs.microsoft.com/fr-fr/azure/sql-database/sql-database-cloud-migrate#method-2-use-transactional-replication
• Export / Import d'un fichier BACPAC : https://docs.microsoft.com/fr-fr/azure/sql-database/sql-database-import
• Utilisation de DMA. Attention, cette opération rendra inaccessible votre base de données durant le process de migration !

Afin de mesurer l'impact de la migration, il est possible d'utiliser l'outil Database Experimentation Assistant (DEA). Cet outil permet la capture de traces, sur un serveur existant, afin d'être rejouées sur SQL Database, SQL Managed instance ou SQL sur Linux. DEA peut être téléchargé ici : https://www.microsoft.com/en-us/download/details.aspx?id=54090

Enfin, comme je l'ai déjà mentionné, il existe d'autres manières de migrer ses bases de données comme l'utilisation de SQL Server Integration Services (SSIS) ou Azure Data Factory v2.

Migration vers Azure SQL Database Managed Instance (PaaS)

SQL Database Managed Instance (MI) est un service managé (PaaS) offrant une compatibilité avec SQL server proche de 100%, tout en supportant des fonctionnalités qui ne sont pas présentes dans SQL Database comme :

• Fonction native de sauvegarde / restauration
• Server lié
• CLR
• SQL Agent
• DB mail (SMTP externe)
• …

De plus, SQL Database MI fonctionne dans son propre VNet, ce qui permet de renforcer la sécurité de votre base de données…. Mais au détriment, aujourd'hui, d'un manque d'intégration avec, par exemple, les autres services Azure.

Une vue d'ensemble complète de SQL Database MI est disponible sur cette page web : https://docs.microsoft.com/fr-fr/azure/sql-database/sql-database-managed-instance#sql-features-supported

Migration vers SQL Database Managed Instance

Encore une fois, après avoir vérifié les prérequis expliqués plus haut dans cet article, il existe plusieurs solutions :

• Azure Database Migration Service (Qui utilisera DMA pour la partie évaluation de l'effort de migration) : https://docs.microsoft.com/fr-fr/azure/dms/dms-overview
• La restauration native à partir d'une URL. J'ai expliqué dans un article, qui date un peu , comment faire ce type de sauvegarde (article en Français): https://blogs.technet.microsoft.com/franmer/2013/11/15/sql-server-2014-intgration-avec-le-stockage-azure/. Sinon cet article est plus récent : https://docs.microsoft.com/fr-fr/sql/relational-databases/backup-restore/sql-server-backup-to-url?view=sql-server-2017

Globalement la sauvegarde à partir d'une URL va suivre le cheminement suivant :

Tous les détails, pour chaque méthode de migration, sont disponibles sur le lien suivant :

https://docs.microsoft.com/fr-fr/azure/sql-database/sql-database-managed-instance-migrate

Attention aux 2 points suivants :

• SQL Database Managed Instance doit être déployé au sein d'un réseau virtuel. L'article suivant donne les détails de configuration : https://docs.microsoft.com/fr-fr/azure/sql-database/sql-database-managed-instance-vnet-configuration
• La première création du service peut prendre jusqu'à 6h. J'ai réalisé un test dans la région Canada Central, et la première création à durée environ 3h15.

  

Migration vers une machine virtuelle Azure avec SQL Server (IaaS)

Dans le cas où il n'est pas encore possible de migrer vos bases SQL server 2008 vers SQL Server 2017, et pour rester couvert par le support, il existe la possibilité de déplacer vos bases de données vers un serveur SQL 2008 hébergé dans une machine virtuelle Azure. Pour cela, il est possible de provisionner directement, à partir d'un modèle existant, une machine virtuelle avec SQL Server 2008. Cela permet de gagner du temps et d'être certain d'avoir la bonne base technologique pour assurer le déplacement de vos bases de données.

Ci-dessous un exemple des modèles disponibles depuis le portail Azure.

Une fois la machine virtuelle provisionnée depuis les modèles proposés, il ne s'agit, ni plus ni moins, d'une migration vers un autre serveur SQL, avec une différence quand même, c'est qu'il va falloir transférer les données vers Azure, afin qu'elles soient accessibles par la machine virtuelle. Mais sinon, toutes les méthodes ci-dessous sont possibles pour bouger vos bases de données vers une machine virtuelle Azure hébergeant SQL Server :

• Effectuer une sauvegarde locale par compression et copier manuellement le fichier de sauvegarde dans la machine virtuelle Azure
• Effectuer une sauvegarde vers une URL et exécuter une restauration dans la machine virtuelle Azure à partir de cette URL
• Détacher, puis copier les fichiers journaux et de données vers le stockage d'objets blob Azure, puis les rattacher à SQL Server dans la machine virtuelle Azure depuis une URL
• Convertir une machine physique locale en disque dur virtuel Hyper-V, effectuer un téléchargement vers le stockage d'objets Blob Azure, puis exécuter un déploiement en tant que nouvelle machine virtuelle en utilisant le disque dur virtuel téléchargé
• Expédition du disque dur avec le Service d'importation/exportation Windows : https://docs.microsoft.com/fr-fr/azure/storage/common/storage-import-export-service
• Si vous disposez d'un déploiement AlwaysOn local, utilisez l' Assistant Ajout d'un réplica Azure pour créer un réplica dans Azure, puis basculez en dirigeant les utilisateurs vers l'instance de base de données Azure
• Utiliser la réplication transactionnelle de SQL Server pour configurer l'instance Azure SQL Server en tant qu'abonné, puis désactiver la réplication en dirigeant les utilisateurs vers l'instance de base de données Azure

Toutes les méthodes énoncées ci-dessus sont détaillées dans l'article suivant :

https://docs.microsoft.com/fr-fr/azure/virtual-machines/windows/sql/virtual-machines-windows-migrate-sql

J'aimerai terminer cet article par un grand merci à Frédéric Pichaut et Nicolas Soukoff qui ont complété et détaillé la partie prérequis, fort de leur grande expérience avec SQL Server. One MS Power ! Merci les gars !

Pour ceux qui seront à Montréal, je vous donne rendez-vous le 28 novembre 2018 au Tech Summit : https://www.microsoftevents.com/profile/web/index.cfm?PKwebID=0x1023303abcd&wt.mc_id=AID737011_QSG_SCL_276355

Franck Mercier

In this article we will see how to use the Custom Vision service. We will train a model to learn how to recognize some types of coats. We will then test this model and finally we will see how to use it within an application.

Prerequisite

• Azure Account
• Visual Studio 2017

The part about the notebook can be done, among others, with:

• Microsoft Azure Notebooks service
• The "Data Science" virtual machine available from Azure portal

In this article, we will use the "Data Science" virtual machine

Creating "Data Science" virtual machine

• Connect to the Azure Portal: https://portal.azure.com
• Click on " Create a resource », and then search for the virtual machine "Data Science"

Select " Data Science Virtual Machine for Linux (Ubuntu) ». Then Click on the button "Create"

Fill in the virtual machine creation form

At the end of the process click on the "Create" button

The virtual machine is now created. We will connect on its Jupyter server. The connection is an URL type:

https://< Your_VM_IPAddress >: 8000

In our case, this address will be:

https://40.86.210.115:8000

The virtual machine IP address can be found on the Azure portal:

The following window may appear. Click on " Details, then Go on the Web page »

In the login window, enter the name and password you have used when creating the virtual machine:

After a few seconds you must land on the Jupyter server home page.

We will create a folder to facilitate our work. Click on "New" then "Folder"

Check the box to the left of the newly created folder (the folder is named « Untitled Folder »), then click the button « Rename » on top of the page.

Rename the folder and then click on the "Rename" button

Creating the Notebook

Enter the previously created folder. Click on the button "New"  then "Python 3"

Once the Notebook created, click "Untitled" and give it a name. Click on "Rename"

Download pictures

In the first cell of the Notebook, copy the code below to recover the training and tests images

! curl-O https://canadastore.blob.core.windows.net/franmerpictures/Pictures.zip

Then click « run » on the toolbar (or use the combination key "Shift Enter" or "Ctrl Enter"). For the rest of the article, after copying the code in the cells, think well to execute the code.

If everything goes well, the Pictures.zip file must appear in your folder

We will now unzip the file. Use the command below in a new cell:

! unzip Pictures.zip

Attention: star between the hooks, means the code is still running. Wait until the star disappears.

Three new files had to appear:

displaying an image

We will display an image and see some basic functions to deal with pictures. We will use « Matplotlib » library. « Matplotlib » documentation can be found here: https://matplotlib.org/.

Copy the code below to a new cell:

#Afficher une image / Display a picture

# Importation de librairie matplotlib / Import the matplotlib libraries

import matplotlib.pyplot as plt

import matplotlib.image as im

img = im.imread('hardshell_jackets/10116634x1038116_zm.jpeg')

imgplot = plt.imshow(img)

In the first run, the following message may appear. This will not affect the outcome.

Retrieve picture information

An image is intrinsically an array of values of pixels (Picture Element) and It is important to be able to recover picture information, in order to use them with object recognition algorithms. Below is a sample code for retrieving certain information. Copy and paste it in a new cell. Don't forget to run the code.

#Information sur l'image / Picture's information

print ("Picture Shape: ")

print(img.shape)

#Total number of pixels is accessed by img.size:

print ("Number of pixels: ")

print (img.size)

#Image datatype is obtained by img.dtype:

print("Picture data type:")

print(img.dtype)

Integration with the "Custom Vision" cognitive service

Microsoft offers many Cognitive Services. The complete list is available through the following link: https://azure.microsoft.com/en-us/services/cognitive-services/directory/

In addition, these services may be called as a web service to return the prediction results.

In this example, we will use the service "Custom Vision". This service is available through the following link: https://customvision.ai/.

But before, we still have small preparations to do in our Notebook.

Installing the Custom Vision SDK

As a first step, we will check the presence of "Pip" and its update.  "Pip" is a tool for installing Python packages. In a new cell of the Notebook, copy the following code:

#installation de pip / pip installation

import sys

! {sys.executable} -m pip freeze

! {sys.executable} -m pip --version

! {sys.executable} -m pip install --upgrade pip

From your notebook, enter the following command: (So we use " Pip "To Install the Package Of the "Custom Vision" cognitive service) :

#Installation du SDK Custom Vision / Install the Custom Vision SDK

! {sys.executable} -m pip install azure-cognitiveservices-vision-customvision

Configuring the "Custom Vision" cognitive service

We will now create a "Custom Vision" service via the following link:

Https://customvision.ai

Click on " Sign In »

Can choose to click on "Continue with trial" or click on "Sign Up for Azure". For our example, we will choose " Continue with trial » :

Once the service is created, retrieve the information from your service by clicking the gear in the top right of the window

Then recover the values of your keys

Return to your Jupyter notebook to assign the key values to the variables:

# Assignez les clefs de votre service "Custom Vision" aux variables / Assign your Custom service keys to variables

training_key = 'c5926d0852854f459c85facff519c759'

prediction_key = '32446a7de71b496798d38fded67fc2da'

Creating a Custom Vision project

From the notebook, we will create a project in the "Custom Vision" cognitive service. In a new cell, copy the code below and run it:

from azure.cognitiveservices.vision.customvision.training import training_api

from azure.cognitiveservices.vision.customvision.training.models import ImageUrlCreateEntry

trainer = training_api.TrainingApi(training_key)

# Create a new project

print ("Creating project...")

project = trainer.create_project("MyProject")

If you return to the "Custom Vison" service web page, you will find a new project:

Labels creation

Before adding images to the service, we will create our first labels to identify the images.

Add the following code to a new cell and run the code:

# Création des labels les images / Add tags for pictures

print("Creating tags")

hardshell_tag = trainer.create_tag(project.id,"Hardshell")

insulated_tag = trainer.create_tag(project.id,"Insulated")

print("Tags created")

Loading Images

Now let's add the images in our custom vision project and add the labels at the same time. Copy and run the code below in a new cell:

# Téléchargez les images / Upload pictures

import os

print("Adding hardshell images...")

hardshell_folder = "jacket_images/hardshell_jackets"

for file in os.listdir(os.fsencode("jacket_images/hardshell_jackets")):

with open(hardshell_folder + "/" + os.fsdecode(file),mode="rb") as Hardshell_img_data:

trainer.create_images_from_data(project.id,Hardshell_img_data,[hardshell_tag.id])

print("Adding insulated images...")

insulated_folder = "jacket_images/insulated_jackets"

for file2 in os.listdir(os.fsencode("jacket_images/insulated_jackets")):

with open(insulated_folder + "/" + os.fsdecode(file2),mode="rb") as insulated_img_data:

trainer.create_images_from_data(project.id,insulated_img_data,[insulated_tag.id])

print("Done !")

Check the presence of the images in the web interface of the cognitive service, and check that the images have the right label.

Training of the project

After adding images and set the different labels, we can now train a model for identifying our images.

In a new cell, copy and run the code below:

#Entrainement du projet / Train the project

import time

print("Training....")

iteration = trainer.train_project(project.id)

print (iteration.status)

while (iteration.status != "Completed"):

iteration = trainer.get_iteration(project.id,iteration.id)

print("Training status: " + iteration.status)

time.sleep(1)

# Set this iteration of the project as the default.

trainer.update_iteration(project.id,iteration.id,is_default=True)

print("Done!")

If we check in the web interface of the cognitive service, a first iteration of our model was created.

Test the model

Now that the model has been trained, we will test it with another set of images

As a first step, we will create a function to convert images and send a data value to the cognitive service endpoint.

To do this conversion, we will create a function. Copy the code below into a new cell:

def read_image_data(img_path):

import numpy as np

from io import BytesIO

import matplotlib.pyplot as plt

# Load the numpy array

#imgArray = np.load(img_path)

imgArray = im.imread(img_path)

# Write the array data to a stream

imageStream = BytesIO()

plt.imsave(imageStream, imgArray)

# Read the stream from the beginning

imageStream.seek(0)

return imageStream.read()

print ('read_image_data function created!')

We will use the model we have trained to make predictions on test images. We will also use the function created previously to convert the images before sending them to the model.

In a new cell in your Notebook, copy the code below:

import os

import time

import numpy as np

#Importation du point de terminaison de prédiction / Import the prediction endpoint

from azure.cognitiveservices.vision.customvision.prediction import prediction_endpoint

from azure.cognitiveservices.vision.customvision.prediction.prediction_endpoint import models

#Création d'une instance du point de terminaison de prédiction

#Create an instance of the prediction endpoint

predictor = prediction_endpoint.PredictionEndpoint(prediction_key)

#Boucle sur l'ensemble des images / Loop through the test images

folder = 'Test'

files = os.listdir(folder)

i=1

x = np.linspace(0,10)

y = np.sin(x)

for file in sorted(files):

#Les images sont traitées dans l'ordre / process files in order

#Récupération du chemin de l'image et lecture des données / Get the file path and read the image data

img_path = os.path.join(folder,file) #Test pour savoir si c'est un fichier ou un dossier

if os.path.isfile(img_path):

print("File name: " + file)

img = im.imread(img_path)

plt.imshow(img)

plt.show()

#plt.plot(x,y)

#plt.figure(i+1)

img_data = read_image_data(img_path)

#Récupération des prédictions pour les images / Get the predicted tags for the image

results = predictor.predict_image(project.id, img_data, iteration.id)

fig = plt.figure()

#Affichage des labels et des probabilités / Display the tag name and probability for each prediction

for prediction in results.predictions:

print ("\t" + prediction.tag_name + ": {0:.2f}%".format(prediction.probability * 100))

print('\n')

#Pause technique :) / Technical Delay

time.sleep(0.25)

i=i+1

Our model returns predictions to try to identify whether the scanned images are coats or not, and if so, what kind of coat is it. Below a sample of prediction results

Using the cognitive service with Visual Studio

Now that our model is ready, It could be interesting to use the service API to Integrate predictions in an application. Below is a quick illustration of integrating the cognitive service into an application.

Start Visual Studio 2017 and create a "Console App"project.

Once the project created, go to « Tools / NuGet Package Manager / Manage NuGet Packages for Solution... " and add the Custom Vision Packages as illustrated below:

Add the 2 following packages:

Then in the file "Program.cs" add the code below. Replace the keys by those of your cognitive service project

using Microsoft.Cognitive.CustomVision.Prediction;

using Microsoft.Cognitive.CustomVision.Training;

using Microsoft.Cognitive.CustomVision.Training.Models;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Threading;

namespace myTutorialCustomVision

{

class Program

{

//private static MemoryStream testImage;

static void Main(string[] args)

{

var projectID = "<YourProjectID>";

var trainingKey = "<YourTrainingKey>";

var predictionKey = "<YourPredictionKey>";

string imagesPath = @"..\..\..\myTutorialCustomVision\Images";

string[] imageFiles = Directory.GetFiles(imagesPath, "*.jpg");

TrainingApi trainingApi = new TrainingApi() { ApiKey = trainingKey };

var project = trainingApi.GetProjects();

Guid myGuid = project[0].Id;

var iterations = trainingApi.GetIterations(Guid.Parse(projectID));

var validIterations = iterations.Where(iter => iter.Status == "Completed");

var lastIterationTrained = validIterations.OrderBy(iter => iter.LastModified).Last();

Iteration lastIteration = trainingApi.GetIteration(myGuid, lastIterationTrained.Id);

lastIteration.IsDefault = true;

trainingApi.UpdateIteration(myGuid, lastIteration.Id, lastIteration);

foreach (var image in imageFiles)

{

FileStream fileStream = new FileStream(image, FileMode.Open, FileAccess.Read);

PredictionEndpoint endpoint = new PredictionEndpoint() { ApiKey = predictionKey };

Console.WriteLine("Making a prediction for picture: " + Path.GetFileName(image));

var result = endpoint.PredictImage(myGuid, fileStream);

foreach (var c in result.Predictions)

{

Console.WriteLine($"\t{c.Tag}: {c.Probability:P1}");

}

}

Console.ReadKey();

}

}

}

Test of the application

To test the application and the predictions, I added a folder images in the "Solution Explorer" and I have copied 2 images in this folder

Result

The application will return, for each image, a prediction for each Labels.

You may get the error " Operation returned an invalid status code '429' » If you are testing with a large number of images. Often this error comes from the fact that your service is in trial version or undersized. To correct the problem, just change the "Pricing tier" on the Custom Vision Web page, in the "Account" section.

Dans cet article, nous allons voir comment utiliser le service Custom Vision. Nous allons entrainer un modèle pour l'apprendre à reconnaitre certains types de manteaux. Nous testerons ensuite ce modèle et enfin nous verrons comment l'utiliser au sein d'une application.

Prérequis

• Un compte Azure
• Visual Studio 2017

La partie concernant le notebook peut se faire, entre autres, avec :

• Le Service Microsoft Azure Notebooks
• La machine virtuelle « Data Science » proposée depuis le portail Azure

Dans cet article, nous allons utiliser la machine virtuelle « Data Science »,

Création d'une machine virtuelle « Data Science »

• Connectez vous sur le portail Azure : https://portal.azure.com
• Cliquez sur « Create a resource », puis recherchez la machine virtuelle « Data Science »

Sélectionnez la machine « Data Science Virtual Machine for Linux (Ubuntu) » puis cliquez sur le bouton « Create »

Remplissez les informations de création de la machine virtuelle

A la fin du process cliquez sur le bouton « Create »

Maintenant que la machine virtuelle est créée, nous allons nous connecter sur son server Jupyter. La connexion se fait avec une URL de type :

https://<Your_VM_IPAddress>:8000

Dans le cas de mon exemple cette adresse sera :

https://40.86.210.115:8000

L'adresse IP de la machine se trouve sur le portail Azure :

Il se peut que la fenêtre suivante s'affiche. Cliquez sur « Details » puis sur « Go on the web page »

Dans la fenêtre de connexion, entrez le nom et le mot de passe que vous avez utilisés lors de la création de la machine virtuelle :

Après quelques secondes, vous devez arriver sur la page d'accueil du serveur Jupyter.

Nous allons créer un dossier pour faciliter notre travail. Cliquez sur « New » puis sur « Folder »

Cochez la case à gauche du dossier nouvellement créé (le dossier se nomme « Untitled Folder »), puis cliquez sur le bouton « rename » un haut de la page.

Renommez le dossier puis cliquez sur le bouton « Rename »

Création du notebook

Entrez dans le dossier précédemment créé. Cliquez sur le bouton « New » puis sur « Python 3 »

Une fois le Notebook créé, cliquez sur « Untitled » et donnez-lui un nom. Cliquez sur « Rename »

Téléchargement des images

Dans la première cellule du Notebook, copiez le code ci-dessous pour récupérer les images d'entrainements et de tests.

! curl -O https://canadastore.blob.core.windows.net/franmerpictures/Pictures.zip

Puis cliquez sur « Run » dans la barre d'outils (ou utilisez la combinaison de touche « Shift Enter » ou « Ctrl Enter »). Pour le reste de l'article, après avoir copié le code dans les cellules, pensez bien à exécuter le code

Si tout se passe bien, le fichier Pictures.zip doit apparaître dans votre dossier

Nous allons maintenant décompresser le fichier. Utilisez la commande-ci-dessous :

! unzip Pictures.zip

Attention : l'astérisque présent entre les crochets, signifie que le code est en cours d'exécution. Il est de bon aloi d'attendre qu'il disparaisse avant d'exécuter le code d'une autre cellule.

Trois nouveaux dossiers ont dû apparaître :

Affichage d'une image

Nous allons afficher une image et de voir comment faire des manipulations simples avec. Nous allons utiliser la librairie « matplotlib ». La documentation détaillée de cette librairie se trouve ici : https://matplotlib.org/.

Copiez le code ci-dessous dans une nouvelle cellule :

#Afficher une image / Display a picture

# Importation de librairie matplotlib / Import the matplotlib libraries

import matplotlib.pyplot as plt

import matplotlib.image as im

img = im.imread('hardshell_jackets/10116634x1038116_zm.jpeg')

imgplot = plt.imshow(img)

Il se peut que lors de la première exécution, le message ci-dessous apparaît. Cela n'aura aucune incidence sur la suite des résultats.

Récupérer des informations de l'image

Une image est intrinsèquement un tableau de valeurs de pixels (picture element) et il est important de pouvoir récupérer certaines informations concernant une image, afin de pouvoir les utiliser avec des algorithmes de reconnaissance d'objet. Ci-dessous, un exemple de code permettant de récupérer certaines informations.

#Information sur l'image / Picture's information

print ("Picture Shape: ")

print(img.shape)

#Total number of pixels is accessed by img.size:

print ("Number of pixels: ")

print (img.size)

#Image datatype is obtained by img.dtype:

print("Picture data type:")

print(img.dtype)

Intégration avec le service cognitif « Custom Vision »

Microsoft propose de nombreux services cognitifs dont la liste complète est disponible via le lien suivant : https://azure.microsoft.com/en-us/services/cognitive-services/directory/

De plus, ces services peuvent être appelés en tant que service web afin de retourner les résultats d'une prédiction.

Dans cet exemple, nous allons utiliser le service « Custom Vision ». Ce service est disponible via le lien suivant : https://customvision.ai/.

Mais avant, il nous reste des petites préparations à faire au niveau de notre Notebook.

Installation du SDK Custom Vision

Dans un premier temps nous allons vérifier la présence de « pip » et de sa mise à jour. « pip » est un outil permettant l'installation de packages Python. Dans une nouvelle cellule du Notebook, copiez le code suivant :

#installation de pip / pip installation

import sys

! {sys.executable} -m pip freeze

! {sys.executable} -m pip --version

! {sys.executable} -m pip install --upgrade pip

Depuis votre notebook, entrez la commande suivante : (nous utilisons donc « pip » pour installer le package du service cognitif « Custom vision ») :

#Installation du SDK Custom Vision / Install the Custom Vision SDK

! {sys.executable} -m pip install azure-cognitiveservices-vision-customvision

Configuration du service cognitif « Custom Vision »

Nous allons maintenant créer un service « Custom vision » en suivant le lien suivant :

https://customvision.ai

Une fois sur la page d'accueil, cliquez sur « Sign in »

Vous avez la possibilité de tester gratuitement nos services cognitifs. Vous pouvez choisir de cliquer sur « Continue with trial » ou cliquez sur « Sign up for Azure ». Pour notre exemple, nous allons choisir « Continue with trial » :

Une fois le service créé, récupérez les informations de votre service en cliquant sur l'engrenage en haut à droite de la fenêtre

Puis récupérez les valeurs de vos clefs

Revenez dans votre Notebook Jupyter pour y assigner les valeurs de vos clefs dans les 2 variables ci-dessous et exécutez le code :

# Assignez les clefs de votre service "Custom Vision" aux variables / Assign your Custom service keys to variables

training_key = 'c5926d0852854f459c85facff519c759'

prediction_key = '32446a7de71b496798d38fded67fc2da'

Création d'un projet Custom Vision

A partir du Notebook, nous allons créer un projet dans le service cognitif « Custom Vision ». Dans une nouvelle cellule, copiez le code ci-dessous et exécutez-le :

from azure.cognitiveservices.vision.customvision.training import training_api

from azure.cognitiveservices.vision.customvision.training.models import ImageUrlCreateEntry

trainer = training_api.TrainingApi(training_key)

# Create a new project

print ("Creating project...")

project = trainer.create_project("MyProject")

Si vous retournez sur l'interface web du « Custom Vison » service, vous devez y trouver un nouveau projet :

Création des labels

Avant d'ajouter des images dans le service, nous allons créer nos premiers labels afin d'identifier les images.

Ajoutez le code suivant dans une nouvelle cellule et exécutez le code :

# Création des labels les images / Add tags for pictures

print("Creating tags")

hardshell_tag = trainer.create_tag(project.id,"Hardshell")

insulated_tag = trainer.create_tag(project.id,"Insulated")

print("Tags created")

Chargement des images

Maintenant nous allons importer les images dans notre projet « Custom Vision » et ajouter les labels en même temps. Copiez et exécutez le code ci-dessous dans une nouvelle cellule :

# Téléchargez les images / Upload pictures

import os

print("Adding hardshell images...")

hardshell_folder = "jacket_images/hardshell_jackets"

for file in os.listdir(os.fsencode("jacket_images/hardshell_jackets")):

with open(hardshell_folder + "/" + os.fsdecode(file),mode="rb") as Hardshell_img_data:

trainer.create_images_from_data(project.id,Hardshell_img_data,[hardshell_tag.id])

print("Adding insulated images...")

insulated_folder = "jacket_images/insulated_jackets"

for file2 in os.listdir(os.fsencode("jacket_images/insulated_jackets")):

with open(insulated_folder + "/" + os.fsdecode(file2),mode="rb") as insulated_img_data:

trainer.create_images_from_data(project.id,insulated_img_data,[insulated_tag.id])

print("Done !")

Vérifier la présence des images dans l'interface web du service cognitif et que les images possèdent le bon label.

Entrainement du projet

Après avoir ajouté les images et défini les différents labels, nous pouvons maintenant entrainer un model permettant d'identifier nos images.

Dans une nouvelle cellule, copiez et exécutez le code ci-dessous :

#Entrainement du projet / Train the project

import time

print("Training....")

iteration = trainer.train_project(project.id)

print (iteration.status)

while (iteration.status != "Completed"):

iteration = trainer.get_iteration(project.id,iteration.id)

print("Training status: " + iteration.status)

time.sleep(1)

# Set this iteration of the project as the default.

trainer.update_iteration(project.id,iteration.id,is_default=True)

print("Done!")

Si on vérifie dans l'interface web du service cognitif, une première itération de notre model a été créée.

Test du model

Maintenant que le modèle a été entrainé, nous allons le tester avec un autre set d'images

Dans un premier temps, nous allons créer une fonction pour convertir les images et envoyer une valeur de données au point de terminaison du service cognitif.

Pour faire cette conversion, nous allons créer une fonction. Copiez le code ci-dessous dans une nouvelle cellule :

def read_image_data(img_path):

import numpy as np

from io import BytesIO

import matplotlib.pyplot as plt

# Load the numpy array

#imgArray = np.load(img_path)

imgArray = im.imread(img_path)

# Write the array data to a stream

imageStream = BytesIO()

plt.imsave(imageStream, imgArray)

# Read the stream from the beginning

imageStream.seek(0)

return imageStream.read()

print ('read_image_data function created!')

Nous allons utiliser le modèle que nous avons entrainer pour réaliser des prédictions sur des images de tests. Nous allons aussi utiliser la fonction créée précédemment pour convertir les images avant de les envoyer au modèle.

Dans une nouvelle cellule de votre Notebook, copiez le code ci-dessous :

import os

import time

import numpy as np

#Importation du point de terminaison de prédiction / Import the prediction endpoint

from azure.cognitiveservices.vision.customvision.prediction import prediction_endpoint

from azure.cognitiveservices.vision.customvision.prediction.prediction_endpoint import models

#Création d'une instance du point de terminaison de prédiction

#Create an instance of the prediction endpoint

predictor = prediction_endpoint.PredictionEndpoint(prediction_key)

#Boucle sur l'ensemble des images / Loop through the test images

folder = 'Test'

files = os.listdir(folder)

i=1

x = np.linspace(0,10)

y = np.sin(x)

for file in sorted(files):

#Les images sont traitées dans l'ordre / process files in order

#Récupération du chemin de l'image et lecture des données / Get the file path and read the image data

img_path = os.path.join(folder,file) #Test pour savoir si c'est un fichier ou un dossier

if os.path.isfile(img_path):

print("File name: " + file)

img = im.imread(img_path)

plt.imshow(img)

plt.show()

#plt.plot(x,y)

#plt.figure(i+1)

img_data = read_image_data(img_path)

#Récupération des prédictions pour les images / Get the predicted tags for the image

results = predictor.predict_image(project.id, img_data, iteration.id)

fig = plt.figure()

#Affichage des labels et des probabilités / Display the tag name and probability for each prediction

for prediction in results.predictions:

print ("\t" + prediction.tag_name + ": {0:.2f}%".format(prediction.probability * 100))

print('\n')

#Pause technique :) / Technical Delay

time.sleep(0.25)

i=i+1

Notre model nous retourne donc des prédictions sur les images afin de tenter d'identifier si les images analysées sont des manteaux ou non, et si oui, quel type de manteau. Ci-dessous des exemples avec des images de tests

Utilisation du service cognitif avec Visual Studio

Maintenant que notre modèle fonction, il est peut-être aussi intéressant d'utiliser l'API du service cognitif afin d'intégrer les prédictions dans une application. Ci-dessous, une illustration rapide d'intégration du service cognitif dans une application.

Démarrez Visual Studio 2017 et créez un projet de type « Console App ».

Une fois le projet créé, dans le menu « Tools / NuGet Package Manager / Manage NuGet Packages for solution… » de Visual studio, et ajoutez les packages du Custom Vision comme illustré ci-dessous :

Rajoutez les 2 packages suivants :

Puis dans le fichier program.cs rajoutez le code ci-dessous. Remplacez les clefs par celles de votre projet du service cognitif

using Microsoft.Cognitive.CustomVision.Prediction;

using Microsoft.Cognitive.CustomVision.Training;

using Microsoft.Cognitive.CustomVision.Training.Models;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Threading;

namespace myTutorialCustomVision

{

class Program

{

//private static MemoryStream testImage;

static void Main(string[] args)

{

var projectID = "<YourProjectID>";

var trainingKey = "<YourTrainingKey>";

var predictionKey = "<YourPredictionKey>";

string imagesPath = @"..\..\..\myTutorialCustomVision\Images";

string[] imageFiles = Directory.GetFiles(imagesPath, "*.jpg");

TrainingApi trainingApi = new TrainingApi() { ApiKey = trainingKey };

var project = trainingApi.GetProjects();

Guid myGuid = project[0].Id;

var iterations = trainingApi.GetIterations(Guid.Parse(projectID));

var validIterations = iterations.Where(iter => iter.Status == "Completed");

var lastIterationTrained = validIterations.OrderBy(iter => iter.LastModified).Last();

Iteration lastIteration = trainingApi.GetIteration(myGuid, lastIterationTrained.Id);

lastIteration.IsDefault = true;

trainingApi.UpdateIteration(myGuid, lastIteration.Id, lastIteration);

foreach (var image in imageFiles)

{

FileStream fileStream = new FileStream(image, FileMode.Open, FileAccess.Read);

PredictionEndpoint endpoint = new PredictionEndpoint() { ApiKey = predictionKey };

Console.WriteLine("Making a prediction for picture: " + Path.GetFileName(image));

var result = endpoint.PredictImage(myGuid, fileStream);

foreach (var c in result.Predictions)

{

Console.WriteLine($"\t{c.Tag}: {c.Probability:P1}");

}

}

Console.ReadKey();

}

}

}

Test de l'application

Pour tester l'application et les prédictions, j'ai rajouté un dossier Images dans le « Solution Explorer » et j'ai copié 2 images dans ce dossier

Résultat

L'application va retourner, pour chacune des images, une prédiction pour chacun des labels.

Il se peut que vous obteniez l'erreur « Operation returned an invalid status code '429' » si vous réalisez le test avec une grande quantité d'images. Souvent cette erreur vient du fait que votre service est soit en version d'essai soit sous-dimensionné. Pour corriger le problème, il suffit juste de changer le « Pricing tier » dans la page web du service custom vision, dans la partie « Account »,

• Part 1: Setting up the Azure environment
• Part 2: Using Databricks
  • Workshop: Data Engineering with Databricks

Part 1: Azure configuration

Resource Group creation

Create an Azure Storage Account

--output table

Containers Creations

Copying files for the workshop

Reference data

Copying transactional data

Create an Azure SQL Database

• You may need to create a SQL server.
• Click on « Configure required settings », « Create a new server ».
• Fill in the SQL server information. Remember your SQL Server password!
• Click on " Select ».

Create SQL tables

Create tables

Drop Table If exists TRIPS_BY_YEAR;

Create Table TRIPS_BY_YEAR (

TAXI_TYPE varchar(10),

TRIP_YEAR int,

TRIP_COUNT bigint

);

Repeat the operations for the following two tables

Drop Table If exists TRIPS_BY_HOUR;

Create Table TRIPS_BY_HOUR (

TAXI_TYPE varchar(10),

TRIP_YEAR int,

TRIP_HOUR INT,

TRIP_COUNT bigint

);

Drop Table If exists BATCH_JOB_HISTORY;

Create Table BATCH_JOB_HISTORY

(

batch_id int,

batch_step_id int,

Batch_step_description varchar(50),

Batch_step_status varchar(10),

Batch_step_time varchar(25)

);

Alter Table BATCH_JOB_HISTORY

Add Constraint Batch_step_time_def

Default CURRENT_TIMESTAMP For Batch_step_time;

You will see your tables from the Azure portal

Create Azure Databricks

Provisioning a cluster and start analyzing your data

Part 2: Using Databricks

Workshop: Data Engineering with Databricks

Create the cluster

• Databricks Runtime Version: 4
• Python Version: 3
• Worker Type: STANDARD_DS13_V2
• Spark Config: spark.hadoop.fs.azure.account.key.<yourStorageAccount>.blob.core.windows.net <yourKey>

Notebooks

Attach notebook to a cluster

Configure your Notebook

Tips with Notebooks

Interactive report with Power BI Desktop

Index

Présentation d'Azure Databricks

Atelier

• Atelier : Data Engineering avec Databricks

Partie 1 : configuration de l'environnement Azure

Création d'un groupe de ressources

Création d'un compte de stockage

Création des containeurs

Copie des fichiers pour le laboratoire

Données de références

Copie des données transactionnelles

Création d'une base Azure SQL Database

Création des tables SQL

Création des tables

DROP TABLE IF EXISTS TRIPS_BY_YEAR;

CREATE TABLE TRIPS_BY_YEAR (

TAXI_TYPE VARCHAR(10),

TRIP_YEAR INT,

TRIP_COUNT BIGINT

);

Répétez l'opération pour les 2 tables suivantes

DROP TABLE IF EXISTS TRIPS_BY_HOUR;

CREATE TABLE TRIPS_BY_HOUR (

TAXI_TYPE VARCHAR(10),

TRIP_YEAR INT,

TRIP_HOUR INT,

TRIP_COUNT BIGINT

);

DROP TABLE IF EXISTS BATCH_JOB_HISTORY;

CREATE TABLE BATCH_JOB_HISTORY

(

batch_id int,

batch_step_id int,

batch_step_description varchar(50),

batch_step_status varchar(10),

batch_step_time varchar(25)

);

ALTER TABLE BATCH_JOB_HISTORY

ADD CONSTRAINT batch_step_time_def

DEFAULT CURRENT_TIMESTAMP FOR batch_step_time;

Vous devez voir vos tables depuis le portail Azure

Création d'une ressource Azure Databricks

Provisionnez un cluster et commencez les analyses

Partie 2 : utilisation de Databricks

Atelier : Data Engineering avec Databricks

Création du cluster

• Databricks Runtime Version : 4
• Python version : 3
• Worker Type : Standard_DS13_v2
• Spark Config : spark.hadoop.fs.azure.account.key.<yourStorageAccount>.blob.core.windows.net <yourKey>

Notebooks

Utiliser un notebook avec un cluster

Configuration des Notebooks

Rapport interactif avec Power BI Desktop

Index

Il se peut, si vous souhaitez installer une VM GPU en suivant l’article ci-dessous,

https://docs.microsoft.com/en-us/azure/virtual-machines/linux/n-series-driver-setup#install-cuda-drivers-for-nc-vms

que vous finissez par rencontrer l’erreur suivante :

« Unsupported kernel version »

On se retrouve donc dans la situation où la version du kernel n’est pas supportée par les drivers que l’on souhaite installer.

Dans cet article, je vais vous donner le pas à pas pour installer les drivers nVidia dans ce cas.

Revenir sur le bon Kernel

Après avoir déployé une machine NC via le portail Azure, faîtes une connexion ssh sur cette machine

Vérifiez la version du kernel avec la commande suivante :

uname -r

Ensuite exécutez la commande suivante pour vérifier les fichiers dans le répertoire boot :

ls -l /boot

On retrouve donc le fichier correspondant à la version du kernel retournée précédemment via la commande « uname -r ».

L’idée ici, est de changer le Kernel et d’utiliser celui listé en-dessous du kernel actuel. Dans notre cas c’est la version 3.10.0-514.e17.x86_64.

Pour ce faire, nous allons entrer la commande suivante. Le changement de Kernel se verra après le reboot :

sudo grub2-set-default 1

La commande suivante va lister les modules qui sont utilisé par le driver nvidia « nouveau »

lsmod | grep nouveau

L’idée maintenant est d’éviter le chargement de ce driver.

Création du fichier « nouveau.conf» avec vi

Dans le dossier /etc/modprobe.d, nous allons créer un fichier de configuration pour « blacklister » le driver.

Changement de répertoire

cd /etc/modprobe.d

Utilisation de l’éditeur de texte vi pour créer le fichier « nouveau.conf »

sudo vi nouveau.conf

Dans vi, utilisez la lettre « i » du clavier pour passer en mode insertion

Puis entrez les 2 lignes suivantes

blacklist nouveau

options nouveau modeset=0

Pour sauvegarder le fichier, appuyez sur la touche « ESC », sur « : » puis sur « w »

Pour vérifier le contenu du fichier, entrez la commande suivante :

Cat nouveau.conf

Redémarrez la machine avec la commande :

sudo reboot

Installation des drivers nvidia

Après le redémarrage de la machine, connectez-vous et exécutez la commande suivante pour vérifier que nous utilisons bien l’ancien Kernel

uname -r

Si on liste les modules sur le driver nouveau, on ne doit avoir aucune valeur en retour :

lsmod | grep nouveau

Maintenant que nous sommes dans l’ancien Kernel, on peut installer les versions des packages et driver nvidia correspondant à ce Kernel.

Récupération des packages :

wget ftp://fr2.rpmfind.net/linux/centos/7.3.1611/os/x86_64/Packages/kernel-headers-3.10.0-514.el7.x86_64.rpm

wget ftp://fr2.rpmfind.net/linux/centos/7.3.1611/os/x86_64/Packages/kernel-devel-3.10.0-514.el7.x86_64.rpm

Installation des 2 packages :

sudo rpm -ihv kernel-devel-3.10.0-514.el7.x86_64.rpm

sudo rpm -ihv kernel-headers-3.10.0-514.el7.x86_64.rpm

Une fois les packages installés, exécutez la commande suivante :

sudo rpm -ivh https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm

Ensuite exécutez la commande suivante et validez par « y » quand nécessaire

sudo yum install dkms

Installation du repository de nVidia

sudo rpm -ivh https://developer.download.nvidia.com/compute/cuda/repos/rhel7/x86_64/cuda-repo-rhel7-8.0.61-1.x86_64.rpm

Installation des drivers nVidia

Exécutez la commande suivante et validez par « y » quand nécessaire

sudo yum install cuda cuda-drivers

Vérification de l’installation des drivers

Afin de s’assurer de l’installation des drivers, exécutez la commande suivante :

cat /proc/driver/nvidia/version

Ensuite exécutez la commande suivante (la commande prend quelques secondes à s’exécuter) :

nvidia-smi

En espérant vous voir aux Microsoft experiences’17

Franck Mercier]]> https://docs.microsoft.com/archive/blogs/franmer/azure-function-copie-de-fichier-csv-dans-une-table-sql-database Mon, 11 Sep 2017 17:16:20 GMT https://blogs.technet.microsoft.com/franmer/?p=7096

Dans cet article, nous allons voir comment créer une fonction permettant de copier des fichiers CSV, qui arrivent dans un container, vers une table SQL Database. Nous allons utiliser la notion de « trigger » permettant de déclencher la fonction lorsqu’un nouveau fichier arrive dans le container. Une fois copié dans la table SQL, le fichier sera alors archivé dans un autre container.

Ci-dessous un schéma illustrant notre fonction :

1. Copie du fichier dans un container du blob storage
2. Déclenchement de la fonction à l’arrivée du fichier
3. Copie du fichier dans une table SQL Database
4. Déplacement du fichier dans un container d’archive

Prérequis

• Un abonnement Azure
• Une base de données SQL Database
• Microsoft Azure Storage Explorer
• SQL Server Management Studio (SSMS)

Création d’Azure Function App

Depuis le portail Azure (https://portal.azure.com), cliquez sur le bouton « + » en haut à gauche.

Puis dans « Compute », cliquez sur « Function App ».

Cliquez sur « Create »

Donnez un nom à votre groupe de ressource et choisissez votre région.

Pour cet exemple, nous créer un « App Service plan ». Le plan S1 suffit pour cet exemple.

(J’ai fait des tests en utilisant un « Consumption Plan », mais lors de fortes charges, ma fonction tombait en timeout).

Nous allons aussi créer un compte de stockage, mais vous pourrez en utiliser un déjà existant

Optionnel : si vous souhaitez avoir des indicateurs de surveillances de votre fonction, activez Application Insights.

Cliquez sur le bouton « Create ».

Vous devez voir apparaître les services suivants dans votre groupe de ressources.

Paramétrage du compte de stockage

Dans le compte de stockage que nous avons créé, nous allons maintenant créer 2 container (et une file d’attente) :

• Un container « fichiers », qui va recevoir les fichiers CSV pour y être traités
• Un container « archives », dans lequel les fichiers vont être déplacés après traitement

Pour la création des containers de nombreuses solutions sont possibles :

• Via le portail Azure
• Via un outil tel que Microsoft Azure Storage Explorer
• Via PowerShell (le compte de stockage existe déjà) :

Login-AzureRMAccount

$SubscriptionName = "Compte de démos"

$ResourceGroupName = "Superfunkycalifragisexy"

$StorageAccountName = "funky69storageaccount"

$StorageContainerName = "fichiers archives"

$Keys = Get-AzureRmStorageAccountKey -ResourceGroupName $ResourceGroupName -Name $StorageAccountName;

$StorageContext = New-AzureStorageContext -StorageAccountName $StorageAccountName -StorageAccountKey $Keys[0].Value;

Select-AzureRmSubscription -SubscriptionName $SubscriptionName

Get-AzureRmStorageAccount -ResourceGroupName $ResourceGroupName -Name $StorageAccountName

$StorageContainerName.split() | New-AzureStorageContainer -Permission off -Context $StorageContext

Si on regarde dans Microsoft Azure Storage Explorer, on doit retrouver nos 2 containers :

Création d’une base SQL Database

Depuis le portail Azure, cliquez sur le signe « + », « Databases » puis « SQL Database »

Définissez les propriétés de votre base SQL Database.

• Sélectionnez le groupe de ressources que vous avez créez au début de ce lab. Dans cet exemple, choisissez : «Superfunkycalifragisexy »
• Vous pouvez utiliser un serveur existant pour héberger votre base de données ou en créer un nouveau. Pour cet exemple, nous allons créer un nouveau serveur.
• Dans la partie « Pricing tier », choisissez au minimum « Standard S0 »

Après la création du serveur et de la base SQL Azure, voici ci-dessous les services Azure présents dans notre groupe de ressources :

Création de la table

Cliquez sur votre base SQL Database

Cliquez sur « Tools »

Cliquez sur « Query editor (preview) », puis sur « Login »

Entrez vos informations de connexion puis cliquez sur « Ok »

Copiez le script ci-dessous, puis cliquez sur « Run » :

CREATE TABLE [dbo].[FranmerProducts](

[UniqueID] [int] IDENTITY(1,1) NOT NULL,

[ID] [int] NULL,

[Product] [nvarchar](200) NULL,

[NomDuFichier] [nchar](200) NULL,

[DateAjout] [datetime] NULL,

CONSTRAINT [PK_FranmerProducts] PRIMARY KEY NONCLUSTERED

(

[UniqueID] ASC

)

)

Pour vérifier si votre table a bien été créée, exécutez la requête suivante :

SELECT TABLE_NAME FROM <Nom de votre base SQL>.INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'

Dans cet exemple, <Nom de votre base SQL> = Anotherloverholenyohead

Sélectionnez la requête, puis cliquez sur « Run »

Création de la fonction Azure

Nous allons créer une fonction Azure qui se déclenche séquentiellement quand un fichier arrive dans le containeur. Cette fonction aura pour but de réaliser la copie du fichier CSV dans une table SQL Database.

Une fonction est composée de plusieurs fichiers :

• run.csx : c’est dans ce fichier que se trouvera l’essentiel de votre code
• function.json : ce fichier contient les metadata de configuration de votre fonction
• project.json : ce fichier permet l’utilisation de packages NuGet

Création de la fonction

Revenez dans votre groupe de ressources et cliquez sur votre fonction

Dans le menu de gauche, cliquer sur le signe « + » à droite de « Functions »

Cliquez sur « Custom function »

Sélectionnez “BlobTrigger C#”

Puis renseignez les champs ci-dessous :

• Name your function : donnez un nom à votre fonction
• Path : remplacez la valeur par défaut « samples-workitems » par le nom de votre container. Dans cet exemple c’est « fichiers »
• Storage account connection : dans la liste déroulante, sélectionnez « AzureWebJobStorage »

Cliquez sur le bouton « Create »

La fonction vient d’être créée. Le fichier run.csx est maintenant ouvert.

Ajout d’une entrée et sortie

En plus du trigger, nous allons maintenant rajouter une entrée et une sortie de type blob à notre fonction

Paramétrage de l’entrée blob

Sur la gauche, cliquez sur « Integrate », « + New Input » puis sur « Azure Blob Storage ».

Cliquez sur le bouton « Select »

Définissez les paramètres de votre entrée :

• Donnez un nom à votre paramètre de sortie
• Dans le champ « Path », entrez la valeur « fichiers/{name} »
• Dans le champ « Storage account connection », sélectionnez la valeur correspondant à votre de compte de stockage. (« AzureWebJobsStorage » dans notre exemple)
• Cliquez sur le bouton « Save »

Paramétrage de la sortie blob

Sur la gauche, cliquez sur « Integrate », « + New Output » puis sélectionnez « Azure Blob Storage »

Cliquez sur le bouton « Select »

Définissez les paramètres de sortie blob

• Donnez un nom à votre paramètre de sortie
• Dans le champ « Path », remplacez « outcontainer/{rand-guid} » par « archives/{name} »
• Dans le champ « Storage account connection », sélectionnez la valeur correspondant à votre de compte de stockage. (« AzureWebJobsStorage » dans notre exemple)
• Cliquez sur le bouton « Save »

Paramétrage manuel des entrées et sorties de la fonction

La définition des liens entre les entrées et sortie de la fonction se trouve dans le fichier « function.json ».

Une des manières pour avoir accès au fichier, est de cliquer sur « Integrate » puis « Advanced editor »

Vous devez arriver sur la vue suivante :

ATTENTION ! Afin d’éviter par la suite d’avoir l’erreur suivante :

Microsoft.Azure.WebJobs.Host: Error indexing method 'Functions.CSV2SQL'. Microsoft.Azure.WebJobs.Host: Cannot bind blob to CloudBlockBlob using access Read.

Modifier le fichier en spécifiant pour les 2 clefs « direction » la valeur «inout ». ci-dessous le code du fichier modifié :

{

"bindings": [

{

"name": "myBlob",

"type": "blobTrigger",

"direction": "in",

"path": "fichiers/{name}",

"connection": "AzureWebJobsStorage"

},

{

"type": "blob",

"name": "inputBlob",

"path": "fichiers/{name}",

"connection": "AzureWebJobsStorage",

"direction": "inout"

},

{

"type": "blob",

"name": "outputBlob",

"path": "archives/{name}",

"connection": "AzureWebJobsStorage",

"direction": "inout"

}

],

"disabled": false

}

Cliquez sur le bouton « Save »

Ajout du code dans la fonction

Cliquez sur le nom de votre fonction pour revenir dans le fichier « run.csx ». Puis collez le code ci-dessous :

Remplacez les valeurs en rouge par vos informations de connexion, puis cliquez sur le bouton « Save »

#r "System.Data"

#r "System.IO.Compression.FileSystem"

#r "Microsoft.WindowsAzure.Storage"

using System;

using System.Data;

using System.Data.SqlClient;

using System.IO;

using System.IO.Compression;

using Microsoft.Azure;

using Microsoft.WindowsAzure.Storage;

using Microsoft.WindowsAzure.Storage.Blob;

public static void Run(Stream myBlob,CloudBlockBlob inputBlob, CloudBlockBlob outputBlob, string name, TraceWriter log)

{

log.Info($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");

DataTable sourceData = new DataTable();

sourceData.Columns.Add("ID");

sourceData.Columns.Add("Product");

sourceData.Columns.Add("NomDuFichier");

sourceData.Columns.Add("DateAjout");

try

{

using (var rd = new StreamReader(myBlob))

{

while (!rd.EndOfStream)

{

var splits = rd.ReadLine().Split(',');

sourceData.Rows.Add(splits[0], splits[1],name,DateTime.UtcNow);

}

}

log.Info($"Début de copie du fichier:{name} dans SQL Database avec BCP....");

SqlBulkCopy bcp = new SqlBulkCopy("Server=tcp:<Nom de votre serveur SQL>.database.windows.net,1433;Initial Catalog=<Nom de votre base de données>;User ID=<Votre compte utilisateur>;Password=<Mot de passe>;Trusted_Connection=False;Encrypt=True;");

// Modifiez le mapping entre votre fichier et votre table SQL si besoin

SqlBulkCopyColumnMapping mapID = new SqlBulkCopyColumnMapping("ID", "ID");

bcp.ColumnMappings.Add(mapID);

SqlBulkCopyColumnMapping mapProduit = new SqlBulkCopyColumnMapping("Product", "Product");

bcp.ColumnMappings.Add(mapProduit);

SqlBulkCopyColumnMapping mapNomFichier = new SqlBulkCopyColumnMapping("NomDuFichier", "NomDuFichier");

bcp.ColumnMappings.Add(mapNomFichier);

SqlBulkCopyColumnMapping mapDateAjout = new SqlBulkCopyColumnMapping("DateAjout", "DateAjout");

bcp.ColumnMappings.Add(mapDateAjout);

bcp.DestinationTableName = "<Nom de votre table SQL>";

bcp.BulkCopyTimeout = 600;

bcp.WriteToServer(sourceData);

log.Info($"Copie du fichier:{name} faite !");

log.Info($"Copie du fichier:{name} dans un container d'archives");

using (var stream = inputBlob.OpenRead())

{

outputBlob.UploadFromStream(stream);

}

log.Info($"Effacement du fichier:{name} qui vient d'être traité");

inputBlob.Delete();

}

catch (Exception ex)

{

log.Error(ex.Message);

}

}

Ci-dessous, une copie d’écran de ma fonction :

Référencement des packages NuGet

Pour que notre fonction puisse s’exécuter sans erreur, il reste à définir les packages Nugets que l’on souhaite utiliser.

Pour ce faire, il est nécessaire de créer un fichier « project.json » avec les références aux packages NuGet que l’on souhaite utiliser.

Sur la droite, cliquez sur le signe « < » pour ouvrir la fenêtre de navigation dans les fichiers

La fenêtre suivante apparaît, cliquez sur le bouton « + Add ».

Dans le champ « File name », entrez le nom de fichier « project.json »

Une fois le fichier créé, copiez le script ci-dessous, puis cliquez sur le bouton « Save »:

{

"frameworks": {

"net46":{

"dependencies": {

"WindowsAzure.Storage": "7.0.0",

"CsvHelper": "2.14.1"

}

}

}

}

Paramétrage du fichier host.json

Afin de s’assurer que la fonction s’exécutera de manière séquentielle, lors de l’arrivé d’un fichier CSV dans le container, il est nécessaire de modifier le fichier « host.json » de notre application. Ce fichier va affecter le comportement de toutes les fonction présentes dans notre application.

Les paramétrages possibles sont expliqués ici : https://github.com/Azure/azure-webjobs-sdk-script/wiki/host.json

Depuis le portail Azure, cliquez sur le nom de votre application (ici, « funky69 »), « Platform Features » puis « App Service Editor »

Dans la fenêtre qui vient de s’ouvrir, cliquez sur « host.json »

Copiez le script ci-dessous :

{

"queues": {

"maxPollingInterval": 2000,

"visibilityTimeout" : "00:00:30",

"batchSize": 1,

"maxDequeueCount": 5,

"newBatchThreshold": 1

}

}

Assurez-vous de voir apparaître le mot « SAVED » avant de quitter la fenêtre.

Redémarrez la fonction (soit un « Restart », soit un « Stop » puis « Start »)

Test de la fonction

Pour tester les fonctions je vais utiliser :

• Microsoft Azure Storage Explorer
• SQL Server Management Studio (SSMS)
• Les fichiers csv qui sont disponibles ici

Test du trigger, de la copie et de l’archivage du fichier

Connectez-vous sur votre compte de stockage avec Microsoft Azure Storage Explorer et copiez un fichier CSV dans le container « fichiers »

Si tout va bien, les logs de la fonction doivent afficher les messages de traitements du fichier

Avec Microsoft Azure Storage Explorer, vérifiez la présence du fichier dans le dossier « archives »

Vérification de la copie dans SQL Database

Précédemment nous avons vu qu’il était possible d’interagir avec notre base SQL depuis le portail Azure. Il est aussi possible d’utiliser SSMS. Connectez-vous à votre base SQL Database avec SSMS. Pour ce faire, récupérez l’adresse de votre serveur SQL depuis le portail Azure :

Puis dans SSMS :

Vérifiez que les données ont bien été copiées dans votre table.

Pour aller plus loin

Imaginons maintenant que l’on vous demande de pouvoir archiver vos fichiers dans des dossiers dont le nom correspond à la date du jour du traitement (comme ça, par hasard ).

Pour ce faire, il suffit de modifier le fichier « function.json » dans l’éditeur avancé :

Modifiez le fichier comme illustré ci-dessous (la section concernant la sortie):

{

"type": "blob",

"name": "outputBlob",

"path": "archives/{datetime: yyyy-MM-dd-hh-mm}/{name}",

"connection": "franmermlstorage_STORAGE",

"direction": "inout"

}

Cliquez sur le bouton « Save »

Vérification :

Test de montée en charge

Pour ce test de montée en charge j’ai créé des fichiers CSV, de tailles différentes que, je vais charger en même temps dans le container avec Microsoft Azure Storage Explorer. Ces fichiers sont disponibles ici : https://1drv.ms/f/s!Am-C-ktMH9lgg8Rl6y4RjorMxsREfg

Du côté d’Azure Storage, les fichiers semblent être traités de manière séquentielle. Je dis ça, car j’ai plutôt l’impression qu’ils sont traités 2 par 2. J’ai bien entendu essayé de passer le paramètre "newBatchThreshold" du fichier « host.json » à 0, mais la fonction ne démarrait plus ☹ ( j’ai l’erreur : « We are not able to retrieve the runtime master key. Please try again later »).

J’ai regardé du côté Application Insight l’occupation de mes ressources. Le plan sélectionné semble tenir la charge même si on constate des pics de consommation au niveau du CPU.

Une fois l’exécution de la fonction terminée, environ 35 minutes pour ce test, je fais une vérification du côté de SQL Database. On retrouve le bon nombre de lignes pour chacun des 30 fichiers :

Le portail nous montre l’utilisation des DTUs de notre SQL Database, configuré ici à 20 DTUs (S1)

Lorsque j’ai fait les tests en utilisant un « App service plan » basé sur la consommation (comsuption plan), j’ai eu de nombreux timeout, même en paramétrant le fichier “host.json” comme dans cet article, et en passant le paramètre de timeout à 10 minutes (par défaut le timeout dans un plan de consommation est de 5 minutes). J’ai pu résoudre le problème en passant ma base au tier premium / premium RS 2. Soit 250 DTU. Mais je trouvais que ça faisait cher payé pour ce genre de « workload ».

Par conséquent, un autre facteur qui peut jouer, c’est le tier du SQL database utilisé. Dans cet article, j’ai utilisé le tier S1. Dans le cas de timeout ou de besoin de traitements plus rapides, vous pouvez augmenter le tier du SQL Database. Ci-dessous le résultat du test avec une base en S3. Le test a duré environ 25 minutes.

Par curiosité, j’ai fait le test avec une base en Premium RS4 (500 DTUs), l’exécution pend moins de 5 minutes. C’est aussi ça l’intérêt du Cloud, pouvoir utiliser l’élasticité en fonction des besoins.

Voici donc pour une utilisation, en mode « serverless », d’un code C# permettant la copie de fichier CSV vers une base SQL Database.

Les fichiers de la fonction se trouvent sur mon OneDrive : https://1drv.ms/f/s!Am-C-ktMH9lgg8dJjyVZ-qTw7xoAIQ

En espérant vous voir aux Microsoft experiences’17

Franck Mercier]]> https://docs.microsoft.com/archive/blogs/franmer/lab-azure-big-data-5-et-fin-analyses-des-donnes-avec-power-bi Mon, 28 Aug 2017 18:03:48 GMT https://blogs.technet.microsoft.com/franmer/?p=6295

Dans le cadre d’un programme de “readiness” interne, j’ai participé à la création de contenu autour du Big Data. Comme j’ai eu de nombreuses demandes pour récupérer le contenu que j’ai créé, je me suis dit que ça pourrait peut-être intéresser d’autres personnes. Donc je partage sur mon blog !

Ce contenu est constitué d’une série d’articles qui va de la création d’un cluster HDInsight à l’exploitation des données.

Sommaire des articles

1. Création d’un cluster HDInsight
2. Utilisation de MapReduce
3. Utilisation de Hive
4. Utilisation de Pig
5. Analyses des données avec Power BI

Pré-requis

Ce lab peut être réalisé avec Power BI Desktop ou les Add-ins Power BI pour Excel 2016. Nous allons utiliser Power BI Desktop qui peut être téléchargé ici

Connexion aux données

Depuis Power BI Desktop, cliquez sur le bouton « Get Data » puis « More… »

Power BI Desktop propose un large choix de connecteurs. Pour ce lab nous allons choisir Data Lake Store comme source de données.

Cliquez sur « Azure » puis sur « Microsoft Azure Data Lake Store (Beta) ». (Vous pouvez choisir une autre source, si le fichier des logs ne trouve pas dans un data lake)

Cliquez sur le bouton « Connect »

Dans la fenêtre de connexion, entrez l’URL de votre lac de données.

Cliquez sur le bouton « Ok » :

Cliquez ensuite sur « Sign in » pour vous authentifier. Cliquez sur le bouton « Connect » :

Une fois connecté au lac de données, une fenêtre d’aperçu apparaît. Cliquez sur le bouton « Edit » :

La fenêtre d’édition de requête s’ouvre. Rechercher le fichier résultant du traitement pig réalisé durant le lab précédent.

Ce fichier à un nom de la forme « part-r- ». Ici, le fichier se trouve dans « user/franmer/output-wikipedialogs ». Pour naviguer dans les données, dans la colonne « Content », cliquez sur « Table »

Ensuite cliquez sur « Table » correspondant à votre nom d’utilisateur :

Puis sélectionnez le dossier contenant le fichier à traiter. Cliquez à nouveau sur « Table » :

Une fois au niveau du fichier, cliquez sur « Binary » :

Un aperçu des données est donc disponible :

Nettoyage des données

Power BI Desktop permet de mettre en forme rapidement les données, afin de pouvoir les exploiter dans des rapports.

L’idée, est de pouvoir isoler les différentes informations que l’on a au sein des colonnes. Si on regarde bien, comme information intéressante, nous avons le titre de l’article et la langue dans lequel cet article a été écrit. L’idée étant d’isoler ces informations au sein de colonnes distinctes.

Faîtes un clic droit sur la colonne « Column1 ». Dans le menu contextuel sélectionnez « Split Column » puis « By Number of Characters… »

Le but étant d’isoler la langue de l’article. Nous allons donc partir de la droite sur 3 caractères. Remplissez le champ « Number of caracters », puis sélectionnez « Once, as far right as possible ». Cliquez sur le bouton « Ok »

Ci-dessous le résultat obtenu. Une nouvelle colonne contient maintenant l’information sur la langue de l’article.

Afin de nettoyer la nouvelle colonne, faîtes un clic droit sur « Column1.2 » puis sélectionnez « Replace Values… »

Remplacez la parenthèse « ) » par aucune valeur dans le champ « Replace with ». Cliquez sur le bouton « Ok ».

Ci-dessous, une copie d’écran du résultat

Continuez de nettoyer le jeu de données de la même manière. Au final on peut imaginer obtenir un résultat comme celui-ci-dessous. Pensez à renommer les colonnes pour une meilleure utilisation des données lors de la phase de création de rapport.

Pour information, sur la droite, vous retrouvez toutes les étapes de vos transformations

Une fois les transformations terminées, cliquez sur le bouton « Close and Apply » :

Création du rapport

Afin de créer un rapport avec Power BI Desktop, assurez-vous d’être dans la partie création de rapport. Pour ce faire, cliquez sur le bouton « Report » à gauche de l’écran.

Une fois dans l’éditeur de rapport, vous avez accès, sur la droite, aux différentes visualisations et aux champs issues de la transformation de données.

Pour commencer à créer un rapport, il suffit, par exemple, de cliquer sur une visualisation puis de rajouter les champs que l’on désire analyser.

Ci-dessous un exemple de rapport avec une visualisation de type « Tree map » :

Afin de rendre lisible ce rapport, il peut être utile d’utiliser les filtres de type « Top N » ou « sélection ». Dans l’exemple du « Tree map », nous allons faire un top N.

Cliquez sur la visualisation que vous souhaitez filtrer. Sur la droite, dans la partie « Filters », sélectionnez le champ sur lequel vous souhaitez appliquer le filtre. Ici, nous allons sélectionner le champ « Article ». Dans la liste déroulante « Filter Type », sélectionnez « Top N ».

Renseignez les différents champs du Filtre TOP N, puis cliquez sur « Apply filter »

Un autre type de filtre peut être utilisé dans un rapport, ce sont les « slicers » :

De plus, les visualisations sont interactives et peuvent servir de filtre aux autres visualisations du rapport par simple clic sur un élément d’une visualisation.

En utilisant les différentes visualisations disponibles, essayez de créer un rapport sur les données récupérées depuis le site Wikipédia. Ci-dessous, un exemple de rapport.

Enrichissement du rapport

Power BI Desktop peut être enrichi avec des visualisations développées par la communauté ou par vous-même. Ces visualisations personnalisées sont disponibles sur le site https://store.office.com/en-us/appshome.aspx?productgroup=PowerBI.

Depuis ce site, vous avez la possibilité de télécharger de nouveaux composants visuels que vous pouvez intégrer à votre rapport Power BI desktop. L’intégration de nouveaux composants visuels se fait directement depuis Power BI Desktop en cliquant sur les trois petits « … » dans la partie « Visualizations… »

Pour aller plus loin

Lors de la récupération et transformation de données, nous avons vu que toutes les étapes étaient répertoriées et accessibles sur la droite de l’écran. Cela permet de revenir sur une étape précise de la transformation pour la modifier si besoin.

Pour modifier une requête existante, dans l’onglet « Home », cliquez sur « Edit Queries » :

Sur la droite, les étapes de transformation sont disponibles pour modification.

De plus, chacune de ces étapes sont retranscrites dans le langage M. L’accès au code de transformation est possible via l’onglet « View », « Advanced Editor ».

Ci-dessous un exemple du code M de notre transformation :

Ci-dessous, un lien vers un article qui utilise le Code M pour invoquer un algorithme de Machine Learning durant une étape de transformation :

https://blogs.technet.microsoft.com/franmer/2014/11/06/power-bi-power-query-machine-learning-et-des-zombies/

C’était le dernier article de cette série. En espérant que cela vous ait été utile.

Franck Mercier]]> https://docs.microsoft.com/archive/blogs/franmer/lab-azure-big-data-4-utilisation-de-pig Mon, 14 Aug 2017 09:19:46 GMT https://blogs.technet.microsoft.com/franmer/?p=5825 Dans le cadre d’un programme de “readiness” interne, j’ai participé à la création de contenu autour du Big Data. Comme j’ai eu de nombreuses demandes pour récupérer le contenu que j’ai créé, je me suis dit que ça pourrait peut-être intéresser d’autres personnes. Donc je partage sur mon blog !

Ce contenu est constitué d’une série d’articles qui va de la création d’un cluster HDInsight à l’exploitation des données.

Sommaire des articles

1. Création d’un cluster HDInsight
2. Utilisation de MapReduce
3. Utilisation de Hive
4. Utilisation de Pig
5. Analyses des données avec Power BI

(Cet article reprend en grande partie celui que j’ai déjà publié ici, mis à jour avec le nouveau portail Azure)

Préparation des données

Dans ce lab, nous allons faire l’analyse des logs du site Wikipedia. Ces logs sont accessibles à l’adresse suivante :

https://dumps.wikimedia.org/other/pageviews/2017/2017-01/

Nous allons récupérer 2 fichiers de logs, mais il est possible d’en récupérer plus.

Pour récupérer les données, il est possible de faire un WGET depuis « Bash on Ubuntu on Windows ».

Création d’un répertoire de données

Avec putty ou « Bash on Ubuntu on Windows », connectez-vous à votre cluster (voir le lab 01_HdInsight). Puis créez un répertoire avec la commande suivante :

hadoop fs -mkdir /example/data/wikipedialogs

Côté Data Lake Store, le dossier est bien créé :

Récupération des données Wikipedia

ATTENTION !! Ne prenez que des fichiers commençant par « pageviews »

Dans cet exemple, nous allons prendre les 2 fichiers suivants :

Nous allons donc passer les 2 commandes suivantes :

wget https://dumps.wikimedia.org/other/pageviews/2017/2017-01/pageviews-20170127-070000.gz

wget https://dumps.wikimedia.org/other/pageviews/2017/2017-01/pageviews-20170127-080000.gz

Les fichiers sont téléchargés dans le cluster, ce qui signifie que si nous détruisons le cluster, les fichiers seront perdus. Nous allons donc copier les fichiers du cluster vers le Data Lake Store. Nous allons utiliser la commande copyFromLocal

hadoop fs -copyFromLocal pageviews-20170127-*.gz /example/data/wikipedialogs

Si maintenant on regarde du côté de Data Lake Store, nous retrouvons bien nos 2 fichiers :

Traitement des données

Maintenant que nous avons récupéré et sécurisé nos données, nous allons pouvoir les exploiter. Dans cet exemple, nous allons utiliser le script pig suivant.

Attention, sur la première ligne, de bien pointer vers le bon répertoire et les bons fichiers.

records = load '/example/data/wikipedialogs/pageviews-*.gz' using PigStorage(' ') as (project:chararray, page:chararray, requests:int, size:int);

filtered_records = filter records by (project == 'en') or (project == 'fr');

records_by_page = group filtered_records by (page, project);

sum_pages = foreach records_by_page generate group, SUM(filtered_records.requests);

result = order sum_pages by $1 desc;

result_limit = limit result 1000;

store result_limit into 'output-wikipedialogs';

Nous allons créer un fichier dans lequel nous allons copier le script ci-dessous.

Dans la console, entrez la commande :

vi script.pig

Une copie d’écran ci-dessous :

Vous entrez donc dans l’éditeur de texte vi (doc de « vi » ici) :

Pour passer en mode insertion, appuyez sur « i »

Collez le script dans l’éditeur de texte :

Pour enregistrer le fichier, il faut passer en mode commande en cliquant sur la touche « esc ».

Pour quitter vi, utilisez la commande suivante :

« :x » puis la touche « return »

Maintenant que nous avons créé un fichier avec le script, nous allons l’exécuter avec la commande :

pig -f script.pig

Le script va s’exécuter et la progression pourra être suivie depuis la console

Monitoring du script pig

Pour monitorer l’exécution du script, connectez-vous sur votre cluster HDInsight depuis le portail Azure. Puis cliquez sur « Yarn»

Dans le dashboard Yarn, sur la gauche, cliquez sur running afin de voir l’avancement d’exécution du script PIG.

Analyse des données avec Power BI

Les fichiers récupérés suite au traitement sont stockés dans Data Lake Store :

Pour analyser les données, nous allons utiliser Power BI Desktop. Cette activité sera détaillée dans le prochain lab.

Franck Mercier]]>