Azure Data Lake Analytics e U-SQL

Embora as tecnologias de big data e Hadoop já existam a mais de uma década, o conceito de big data e análises de big data estão se tornando cada vez mais relevantes. Enquanto a versão inicial do Hadoop era capaz de lidar apenas com cargas de trabalho em batch, agora o ecossistema do Hadoop possui ferramentas para outros casos de uso, como dados estruturados, dados de streaming, processamento de eventos, processamento de aprendizado de máquina e processamento de grafos.

Embora o ecossistema do Hadoop tenha várias ferramentas como Hive, Impala, Pig, Storm e Mahout para fornecer o conjunto completo de recursos, frameworks mais recente de análise de dados como o Spark possuem uma abordagem integrada para lidar com diferentes tipos de cargas de trabalho.

O Azure Data Lake Analytics, ou ADLA, é um dos mais novos mecanismos de análise de big data. O ADLA é o serviço de análise sob demanda totalmente gerenciado da Microsoft na Azure Cloud. Juntamente com o Azure Data Lake Storage e o HDInsight, o Azure Data Lake Analytics forma a oferta completa de análise e análise de dados em cloud da Microsoft. O Azure Data Lake Analytics introduz uma nova linguagem de processamento e consulta de big data chamada U-SQL. Este artigo fornece uma visão geral da linguagem U-SQL e como usá-la em algumas aplicações.

Azure Data Lake

O Azure Data Lake é o serviço de data lake da Microsoft no cloud público do Azure, que é composto por vários tipos de serviços, incluindo armazenamento de dados, processamento, análise e outros como bancos de dados NoSQL, banco de dados relacional, data warehouse e ferramentas de ETL.

Serviços de Armazenamento

• O Azure Data Lake Storage ou ADLS é um armazenamento em cloud escalável criado propositadamente para análises, com base no padrão de código aberto do HDFS;
• O Azure Blob Storage tem como proposta geral o armazenamento de objeto gerenciado de uso geral para o Azure.

Analytics e Serviços de Processamento

• Azure Data Lake Analytics ou ADLA - Serviço de análise sob demanda totalmente gerenciado do Azure Cloud. Oferece suporte à nova linguagem de processamento de big data U-SQL, além do .NET, R e Python;
• HDInsight - O HDInsight fornece clusters Hadoop gerenciados em execução no Azure e é baseado na distribuição Hadoop do Hortonworks Data Platform (HDP). Oferece suporte às ferramentas do ecossistema do Hadoop, incluindo Spark, Hive, Map Reduce, HBase, Storm e Kafka;
• Azure Databricks - serviço de análise serverless gerenciado com base no Azure Spark. Suporta o Jupyter/iPython/Zeppelin Notebook, além de outros recursos de comunicação, suporta também o Scala, Python, R e SQL.

Serviços Complementares

• Cosmos DB - O serviço de banco de dados NoSQL multimodal gerenciado, serverless do Azure;
• Azure SQL Database - Um banco de dados relacional gerenciado como serviço/DBaaS no Azure;
• Azure SQL Datawarehouse - Solução Enterprise Data Warehouse (EDW) cloud em execução no Azure. Usa sistemas distribuídos familiares e conceitos de data warehousing, como Massively Parallel Processing (MPP), armazenamento colunar, compactação, etc. para garantir um desempenho rápido para consultas complexas;
• Azure Analysis Services - Um mecanismo de análise totalmente gerenciado no Azure; ajuda a criar modelos semânticos no cloud. É baseado no conhecido SQL Server Analysis Server, que é um mecanismo de análise local baseado no SQL Server. A partir de agora, o Serviço de Análise do Azure oferece suporte apenas a Modelos Tabulares e não oferece suporte a Modelos Multidimensionais (lembram-se dos cubos?);
• Azure Data Factory - É um ETL cloud e serviço de integração de dados, serverless e fornece conectores prontos para uso em mais de 50 sistemas/serviços cloud ou local, como Armazenamento de Blob do Azure, o Cosmos DB, Banco de Dados SQL do Azure, SQL Server/MySQL/PostgreSQL e até serviços de terceiros, como SFDC , Dropbox, etc. Pode mover dados entre serviços cloud, de sistemas locais para cloud ou vice-versa.

A Figura 1 abaixo mostra esses vários serviços cloud que são oferecidos no Azure Cloud da Microsoft .

Figura 1: Serviços oferecidos no Azure Data Lake

A arquitetura de aplicativos com base em big data e data lake na plataforma cloud do Azure é demonstrado abaixo na Figura 2.

Figura 2: Arquitetura típica de big data/data lake/ETL/analytics no Azure

Introdução ao U-SQL

O U-SQL é a linguagem de processamento e consulta de big data do Azure Data Lake Analytics. É uma nova linguagem criada pela Microsoft, especialmente para o Azure Data Lake Analytics. O U-SQL combina linguagem declarativa do tipo SQL com o poder programático do C#, inclui tipos e expressões avançadas do C#. O U-SQL fornece os conceitos familiares de processamento de big data, como "schema on read", "lazy evaluation", processadores personalizados e redutores. Os engenheiros de dados que usavam linguagens como Pig, Hive e Spark anteriormente encontrariam semelhança com elas. Os desenvolvedores com conhecimento em C# e SQL considerariam o U-SQL uma linguagem fácil de aprender e começar a usar.

 
Figura 3: Como o U-SQL se relaciona com C # e SQL

Embora o U-SQL use muitos conceitos e palavras-chave do SQL, não é compatível com ANSI SQL. O U-SQL adiciona recursos de manipulação de arquivos não estruturados usando palavras-chave como EXTRACT e OUTPUT.

Atualmente, o ADLA e o U-SQL podem ser usados apenas para processamento batch. O mesmo não fornece análise de streaming ou capacidade de processamento de eventos.

Conceitos e scripts de U-SQL

A lógica de consulta e processamento U-SQL é gravada em arquivos com extensão ".usql" chamados scripts U-SQL. O IDE do Visual Studio ou o portal do Azure podem ser usados para criar esses scripts. Um projeto U-SQL no Visual Studio contém vários scripts, códigos por trás de arquivos e assemblies de referência relacionados.

A Figura 4 abaixo mostra a captura de tela de um projeto U-SQL no IDE do Visual Studio.

 
Figura 4: Um projeto U-SQL no Visual Studio

• Os scripts U-SQL seguem o padrão familiar de Extração/Recuperação, Transformação e Carregamento/Saída (ETL) usado por outras linguagens de big data, como Pig ou Spark. Podendo extrair dados de arquivos de texto (arquivos de texto não estruturados e arquivos semi-estruturados, como JSON ou XML) além de tabelas;
• O U-SQL impõe um esquema ao recuperar dados não estruturados de arquivos - isso ajuda na execução de operações semelhantes a SQL dos dados recuperados;
• Um conjunto de linhas é a estrutura de dados principal do U-SQL. É usado para extrair dados de um arquivo/tabela de entrada e realizar uma transformação, bem como para gravar no destino de saída. Os conjuntos de linhas não são ordenados, o que ajuda o Azure Data Analytics Engine a paralelizar o processamento usando vários nós de processamento;
• Os scripts U-SQL podem usar tipos, operadores e expressões do C#;
• Os scripts U-SQL usam construções SQL como SELECT, WHERE, JOIN e outra definição de dados (DDL) e linguagem de manipulação de dados (DML). Todas as palavras-chave devem ser escritas apenas em letras maiúsculas;
• Oferece suporte a construções de fluxo de controle como IF ELSE, mas não suportam o loops como While ou For.

Figura 5: Fluxo de dados no script U-SQL

O que é necessário para o desenvolvimento local U-SQL

A Microsoft fornece uma configuração semelhante a um emulador para experimentar o U-SQL e o Azure Data Lake em computadores ou laptops. Para isso, são necessários três componentes:

1. Visual Studio 2017 ou 2019.
2. Azure SDK (versão 2.7.1 ou superior), que vem com os SDKs do cliente para interagir com os serviços cloud do Azure necessários para armazenamento, computação, etc.
3. Ferramentas do Azure Data Lake e Stream Analytics para Visual Studio (versão 2.4), que é um plug-in para o desenvolvimento local de U-SQL e Azure Data Lake. Depois de instalá-los, os modelos de projeto relevantes do Azure Data Lake Analytics (e outros) serão adicionados ao Visual Studio, como mostrado abaixo. Selecione Projeto U-SQL para iniciar.

Figura 6: captura de tela do modelo de projeto

Primeiro script U-SQL

Para o primeiro script U-SQL, usaremos um conjunto de dados que constitui a classificação de restaurantes em Bangalore, Índia. Os dados brutos estão em arquivos CSV e têm as seguintes colunas:

• rest_id - ID exclusivo do restaurante;
• name - nome do restaurante;
• address - endereço do restaurante;
• online_order - se o pedido on-line está disponível no restaurante ou não;
• book_order - se as opções de reserva de mesa estão disponíveis ou não;
• rate - classificação geral do restaurante;
• votes - número total de classificações para o restaurante;
• phone - número de telefone do restaurante;
• location - bairro em que o restaurante está localizado;
• rest_type - tipo de restaurante (por exemplo, jantar casual, lanches rápidos, entrega, padaria, sobremesas etc.);
• favorite_dish_id - identificação do prato mais favorito do restaurante.

A tabela abaixo mostra os dados da amostra.

Figura 7: Tabela de classificação de restaurantes com dados de amostra

O script abaixo lê dados de classificação de restaurantes de um arquivo CSV e grava os mesmos dados em um arquivo TSV. Não aplica ainda uma etapa de transformação.

// Script - RestaurantScript.usql
// Data is extracted from input file (CSV) and stored in employees rowset variable
@restaurant_ratings =
    EXTRACT rest_id int,
            name string,
            address string,
            online_order bool,
            book_order bool,
            rate double,
            votes int,
            phone string,
            location string,
            rest_type string,
            favorite_dish_id int
    FROM "/Samples/Data/restaurants_ratings.csv"
    USING Extractors.Csv();

// No Transformation – extracted data is loaded as is to output file (TSV)
OUTPUT @restaurant_ratings
TO "/output/restaurants_out.tsv"
USING Outputters.Tsv();

Os scripts gravam os conjuntos de linhas inteiros do restaurante no arquivo de saída em um formato separado por tabulação.

Observe que os tipos de dados C# são usados aqui (por exemplo, string e não char/varchar, como normalmente usado no SQL). Não apenas podemos usar os tipos de dados do C#, mas também a facilidade de expressões de uma linguagem de programação expressiva.

Script U-SQL com etapa de transformação

// Script - RestaurantScript.usql
// Variables for input and output file name and paths
DECLARE @inputFile = "/Samples/Data/restaurants_ratings.csv";
DECLARE @outputFile = "/output/restaurants_out.tsv";

// Data is extracted from input file (CSV) and stored in employees rowset variable
@restaurant_ratings =
    EXTRACT rest_id int,
            name string,
            address string,
            online_order bool,
            book_order bool,
            rate double,
            votes int,
            phone string,
            location string,
            rest_type string,
            favorite_dish_id int
    FROM @inputFile
    USING Extractors.Csv(skipFirstNRows:1); // Skip first row which contain headers

// Transformation Step: Columns are renamed and no of rows are filtered
@bestOnlineRestaurants =
    SELECT name.ToUpper() AS Name,    // Converting the names to uppercase
           rate AS Rating,
           online_order AS OnlineOrder,
           phone AS Phone,
           location AS Location,
           rest_type AS Category,
           favorite_dish_id AS FavoriteDishId
    FROM @restaurants_rating
    WHERE rate > 4 && online_order == true;

// Load transformed data to output file
OUTPUT @bestOnlineRestaurants
TO @outputFile
USING Outputters.Tsv(outputHeader:true); // Write column names/headers to output file

Estendendo a expressão U-SQL usando código customizado

O U-SQL suporta expressões customizados escritas em C#. O código C# reside no código atrás dos arquivos. Observe no diagrama abaixo que cada arquivo .usql possui um arquivo .usql.cs associado no qual o código C# customizado está.

 
Figura 8: Projeto U-SQL com vários scripts e códigos por trás dos arquivos

// Code behind C# file - RestaurantScript.usql.cs
namespace UsqlApp1
{
    public static class Helpers
    {
        public static string FormatRestaurantName(string name, string location, string restaurantType)
        {
            return name + " (" + restaurantType + ") - " + location;
   // Note that U-SQL does not yet support new C# 7.0 string interpolation
               // return $"{name} ( {restaurantType} ) - {location}";
        }
    }
}

// Script - RestaurantScript.usql
// Variables for input and output file name and paths
DECLARE @inputFile = "/Samples/Data/restaurants_ratings.csv";
DECLARE @outputFile = "/output/restaurants_out.tsv";

// Data is extracted from input file (CSV) and stored in employees rowset variable
@restaurant_ratings =
    EXTRACT rest_id int,
            name string,
            address string,
            online_order bool,
            book_order bool,
            rate double,
            votes int,
            phone string,
            location string,
            rest_type string,
            favorite_dish_id int
    FROM @inputFile
    USING Extractors.Csv(skipFirstNRows:1); // Skip first row which contain headers

// Transformation Step: Columns are renamed and no of rows are filtered
@bestOnlineRestaurants =
    SELECT USQLApp1.Helpers.FormatRestaurantName(name, location, rest_type) AS Name,
           rate AS Rating,
           online_order AS OnlineOrder,
           phone AS Phone,
           favorite_dish AS FavoriteDish
    FROM @restaurant_ratings
    WHERE rate > 4 && online_order == true;

// Load transformed data to output file
OUTPUT @bestOnlineRestaurants
TO @outputFile
USING Outputters.Tsv(outputHeader:true); // Write column names/headers to output file

Script U-SQL executando joins

O U-SQL suporta joins entre dois conjuntos de dados diferentes. Fornecendo Inner Join, Outer Join, Cross Join, etc.

No seguinte snippet de código, executa-se um inner join entre um conjunto de dados de restaurantes e um conjunto de dados de ingredientes de prato.

// Script - RestaurantScript.usql
DECLARE @inputFile = "/Samples/Data/restaurants_ratings.csv";
DECLARE @outputFile = "/output/restaurants_out.tsv";

// Data is extracted from input file (CSV) and stored in employees rowset variable
@restaurant_ratings = // Code not shown for brevity. Exact same code as above example

// Transformation Step: Columns are renamed and no of rows are filtered
@bestOnlineRestaurants = // Code not shown for brevity. Exact same code as above example

Agora, precisaríamos de dados sobre pratos e seus ingredientes. Embora esses dados normalmente estejam presentes em uma fonte externa, usaríamos um conjunto de linhas na memória aqui.

// Declare an in-memory rowset for dish ingredients containing dish id, name of dish and // ingredients.

@dish_ingredients =
    SELECT
        * FROM
              (VALUES
               (1, "Biryani", "Rice, Indian spices, Vegetables, Meat, Egg, Yoghurt, Dried Fruits"),
               (2, "Masala Dosa", "rice, husked black gram, mustard seeds, fenugreek seeds, salt, vegetable oil, potatoes, onion, green chillies, curry leaves, turmeric"),
               (3, "Cake", " sugar, butter, egg, cocoa, creme, salt")
              ) AS D(DishId, Dish, Ingredients);
// Perform an Inner Join between @bestOnlineRestaurants and @dish_ingredients rowset
@rs_innerJn = SELECT
        r.Name,
        r.Rating,
        i.Dish,
        i.Ingredients
FROM @bestOnlineRestaurants AS r
INNER JOIN @dish_ingredients AS i
ON r.FavoriteDishId == i.DishId;

// Write to output file
OUTPUT @rs_innerJn
TO @outputFile
USING Outputters.Tsv(outputHeader:true);

O código retornará os restaurantes com classificações mais altas, juntamente com os detalhes do ingrediente de seu prato favorito, que são recuperados ao ingressar no conjunto de linhas de detalhes do restaurante com o conjunto de linhas de ingredientes do prato através da junção interna.

Figura 9: Projeto U-SQL com vários scripts e códigos por trás de arquivos

Script U-SQL usando funções internas

O U-SQL fornece uma série de funções internas, incluindo funções de agregação, funções analíticas, funções de classificação, etc. Abaixo estão alguns exemplos.

No script abaixo, foi usado funções de agregação incorporadas como MIN, MAX, AVG e STDEV para cada tipo de restaurante.

// Declare variables for input and output files
DECLARE @inputFile = "/Samples/Data/restaurants_raw_data.csv";
DECLARE @outputFile = "/output/restaurants_aggr.csv";

@restaurant_ratings =
    EXTRACT rest_id int,
            name string,
            address string,
            online_order bool,
            book_order bool,
            rate double,
            votes int,
            phone string,
            location string,
            rest_type string,
            favorite_dish_id int
    FROM @inputFile
    USING Extractors.Csv(skipFirstNRows:1);

@output =
    SELECT
           rest_type AS RestaurantType,
           MIN(rate) AS MinRating,
           MAX(rate) AS MaxRating,
           AVG(rate) AS AvgRating,
           STDEV(rate) AS StdDevRating
    FROM @restaurants_ratings
    GROUP BY rest_type;

// Write to output file
OUTPUT @output
TO @outputFile
USING Outputters.Csv(outputHeader:true);

Catálogo U-SQL

Até agora, nos concentramos em dados não estruturados e semi-estruturados sendo lidos de arquivos e gravados em arquivos. Embora um dos pontos fortes do U-SQL seja operar dados não estruturados armazenados em arquivos e fornecer uma visão esquematizada sobre dados não estruturados, o mesmo pode gerenciar dados estruturados, fornecendo um sistema geral de catálogo de metadados como o Hive. Abaixo está uma lista de objetos principais suportados pelo U-SQL:

• Database: o U-SQL suporta bancos de dados semelhantes a outros sistemas de big data como o Hive;
• Database Schema: os database schemas agrupam objetos relacionados presentes em um banco de dados, exatamente como os bancos de dados relacionais;
• Tables and Indexes: as tabelas são containers para armazenar dados estruturados. As tabelas podem conter colunas de diferentes tipos de dados. Os dados da tabela são armazenados em arquivos. As tabelas fornecem vantagens adicionais acima das visualizações apenas esquematizadas sobre arquivos não estruturados, como indexação, particionando dados da tabela em vários buckets, com cada bucket armazenado em backup por um arquivo;
• Views: as visualizações U-SQL são de dois tipos - visualizações baseadas em uma tabela U-SQL, e visualizações que apontam para um arquivo e usam EXTRACT para obter os dados;
• Functions: suportam funções escalares e com valor de tabela.
• Procedures: as procedures são semelhantes às funções, mas não retornam nenhum valor;
• Assemblies: o U-SQL suporta o armazenamento de assemblies .NET que estendem scripts U-SQL com expressão personalizada.

Agora, digamos que em nosso exemplo de classificação de restaurantes, gostaríamos de analisar melhor os restaurantes com classificações baixas. Para fazer isso, gostaríamos de mover todos os restaurantes com menos de quatro estrelas para uma tabela U-SQL para análise posterior.

U-SQL database, tables and indexes

No exemplo abaixo, será criado um banco de dados U-SQL com um esquema e uma chave de índice. Como não estamos criando um esquema específico, a tabela será criada no esquema default 'dbo' (Lembra do SQL Server?) dentro do banco de dados.

O exemplo de código abaixo mostra como criar esta tabela.

// Script - RestaurantScript.usql
DECLARE @inputFile = "/Samples/Data/restaurants_ratings.csv";
DECLARE @outputFile = "/output/restaurants_out.tsv";

// Data is extracted from input file (CSV) and stored in employees rowset variable
@restaurant_ratings = // Code not shown for brevity. Exact same code as above example

// Transformation Step: Filter only those restaurants with rating less than 4
@lowRatedRestaurants =
    SELECT rest_id AS RestaurantId,
           name AS Name,
           rate AS Rating,
           online_order AS OnlineOrder,
           phone AS Phone,
           location AS Location,
           rest_type AS Category,
           favorite_dish_id AS FavoriteDishId
    FROM @restaurants_ratings
    WHERE rate < 4;

// Insert Low rated restaurant details to U-SQL Catalog
// Create the database if it does not exist already
CREATE DATABASE IF NOT EXISTS RestaurantsDW;
USE RestaurantsDW;

// Drop the table if it exists
DROP TABLE IF EXISTS dbo.LowRatedRestaurants;

// Create the table by specifying the column schema and index
CREATE TABLE dbo.LowRatedRestaurants(
    RestaurantId int,
    Name string,
    INDEX idx
        CLUSTERED (Name DESC)
        DISTRIBUTED BY HASH(Name),
    Rating double,
    OnlineOrder bool,
    Phone string,
    Location string,
    Category string,
    FavoriteDishId int
);

// Insert the rowset data to the U-SQL table created just before
INSERT INTO dbo.LowRatedRestaurants
SELECT * FROM @lowRatedRestaurants;

U-SQL views

As views em U-SQL são semelhantes às views do banco de dados - não armazenam fisicamente os dados e fornecem uma visualização sobre os dados armazenados na tabela ou nos arquivos. As views podem ser baseadas em tabela ou em uma extração em arquivos.

O script de exemplo abaixo mostra como criar uma view com base em uma extração.

USE DATABASE RestaurantsDW;
// Delete the View if it already exists
DROP VIEW IF EXISTS RestaurantsView;

// Create the View based on an extraction
CREATE VIEW RestaurantsView AS  
    EXTRACT rest_id int,
            name string,
            address string,
            online_order bool,
            book_order bool,
            rate double,
            votes int,
            phone string,
            location string,
            rest_type string,
            favorite_dish_id int
    FROM "/Samples/Data/restaurants_raw_data.csv"
    USING Extractors.Csv(skipFirstNRows:1); // Skip first row which contain headers

Para executar a view o seguinte código é usado:

@result = SELECT * FROM RestaurantsDW.dbo.RestaurantsView;
OUTPUT @result
TO "/output/Restaurants_View.csv"
USING Outputters.Csv();

Funções com valor de tabela U-SQL (TVF)

O U-SQL suporta a função escalar e a função com valor de tabela (TVF). As funções levam de zero a muitos argumentos e retornam um único valor escalar ou uma tabela, que é um conjunto de dados composto por colunas e linhas.

O trecho de código abaixo mostra primeiro como criar um TVF e depois como invocá-lo. Pegando um único parâmetro e retornando uma tabela.

CREATE DATABASE IF NOT EXISTS RestaurantsDW;
USE DATABASE RestaurantsDW;

DROP FUNCTION IF EXISTS tvf_SearchRestaurants;

// Create the Table Valued Function that accepts Restaurant type as string
// and returns a table that contains matched restaurant details.
CREATE FUNCTION tvf_SearchRestaurants(@RestaurantType string)
RETURNS @searchRestaurants TABLE(rest_id int, name string, address string,
                                    online_order bool, book_order bool, rate double,
                                    votes int, phone string, location string,
                                    rest_type string, favorite_dish_id int)
    AS
BEGIN
    @allRestaurants =
        EXTRACT rest_id int,
            name string,
            address string,
            online_order bool,
            book_order bool,
            rate double,
            votes int,
            phone string,
            location string,
            rest_type string,
            favorite_dish_id int
        FROM "/Samples/Data/restaurants_raw_data.csv"
        USING Extractors.Csv(skipFirstNRows:1); // Skip first row which contain headers

    @searchRestaurants =
        SELECT *
        FROM @allRestaurants
        WHERE rest_type == @RestaurantType;

RETURN;
END;

Agora, vamos chamar a função com valor de tabela que acabamos de criar e passar o valor "Bakery" como parâmetro - ele retornaria todos os restaurantes do tipo Bakery.

OUTPUT RestaurantsDW.dbo.tvf_SearchRestaurants("Bakery")
TO "/output/BakeryRestaurants.csv"
USING Outputters.Csv();

Estudo de Caso

O estudo de caso a seguir destaca o uso do Azure Data Lake Analytics e a linguagem U-SQL em um grande programa estratégico de transformação digital de vários anos. O cliente, uma grande empresa de seguros, ao longo do ano adquiriu várias seguradoras e corretoras e, como resultado, usou vários sistemas de interação para relacionar-se com os clientes por e-mail, texto/SMS, bate-papo na web/celular e chamadas. Devido à abordagem fraturada, ficou muito difícil para o cliente analisar os dados de interação do cliente.

Enquanto o cliente embarcou em uma jornada para criar uma plataforma omni-channel e um centro de contato integrado para atendimento ao cliente em vários canais (e-mail, texto, chat, chamadas de voz), sua opção tática imediata foi analisar dados de várias fontes para e-mail, texto/SMS, bate-papo e registros de chamadas.

Uma solução com base no Azure Data Lake foi desenvolvida para atender à necessidade imediata de analisar dados de diferentes sistemas, em diferentes formatos. Os dados de vários sistemas de origem foram movidos para o Azure Data Lake Store e depois analisados usando o Azure Data Lake Analysis e também U-SQL.

1. Ingestão - Na fase de ingestão, dados não estruturados e estruturados de duas fontes diferentes (dados de E-mail/Texto/Bate-papo e Registro de Chamadas) são movidos para o Azure usando o serviço ETL do Azure Data Factory.
2. Armazenamento - Os dados brutos são armazenados no ADLS / Data Lake Storage do Azure como arquivos simples.
3. Analise - Vários tipos de análise, incluindo filtragem, junções, agregação, etc. são executados em U-SQL.
4. Modelar e servir - Os dados analisados são armazenados em tabelas estruturadas para consumo posterior dos relatórios personalizados em Power BI pelos usuário.

Figura 10: Pipeline do Azure Data Analytics

Conclusões

O Data Lake Storage and Analytics do Azure surgiu como uma forte opção para executar cargas de trabalho de análise e big data em paralelo ao Azure HDInsight e Azure Databricks. Embora ainda esteja em seus primeiros dias e carente de recursos de processamento de streaming e eventos, seu poder está na nova linguagem U-SQL, que combina a simplicidade e a presença marcante do SQL com a tecnologia chave da Microsoft, a poderosa linguagem C#. Além disso, as ferramentas de desenvolvimento da Microsoft, como o Visual Studio e o recurso de desenvolvimento/teste local, a tornam uma poderosa concorrente no espaço de big data e analytics.

Sobre o Autor

Aniruddha Chakrabarti possui 19 anos de experiência distribuídos em estratégia, consultoria, desenvolvimento de produtos e serviços de TI. Ele tem experiência em várias funções, incluindo arquitetura de soluções, pré-vendas, arquitetura de tecnologia, liderança de entrega e gerenciamento de programas. Como AVP do digital em Mphasis, Chakrabarti é responsável por pré-vendas, soluções, RFP/RFI e arquitetura de tecnologia de grandes negócios e programas digitais. Antes de ingressar na Mphasis, ele desempenhou várias funções de liderança e arquitetura na Accenture, Microsoft, Target, Misys e Cognizant. Suas áreas de foco incluem cloud, big data / analytics, AI/ML, PNL, IoT, sistemas distribuídos, microsserviços e DevOps.