Category Archives: Big Data

Instalando Anaconda no Ubuntu

Big Data No Comments

Este post demonstra a instalação e comandos básicos do Anaconda no Ubuntu.

Baixando o Anaconda

Acesse a URL

https://www.anaconda.com/distribution/

Instalando o Anaconda

Executar o arquivo Anaconda3-2018.12-Linux-x86_64.sh

$ sh Anaconda3-2018.12-Linux-x86_64.sh

A instalação será efetuada na pasta padrão ~/anaconda3

Configurando Path

Para adicionar o caminho dos programas no Path, digite:

$ export PATH=~/anaconda3/bin:$PATH

Atualizando o Conda

$ conda update -n base -c defaults conda

Criando ambiente

Para criar um ambiente, digite:

$ conda create --name myenv

Ativando ambiente

$ source activate myenv

Rodando o Jupyter

$ jupyter notebook

Executando o Anaconda Navigator

O Anaconda Navigator é uma interface gráfica incluída no Anaconda que permite que você inicie aplicativos e gerencie pacotes, ambientes e canais Conda sem a necessidade de usar linha de comando.

$ anaconda-navigator

Cursos gratuitos – Data Science Academy

Big Data No Comments

Abaixo, alguns cursos gratuitos da Data Science Academy

Curso Gratuito de Microsoft Power BI (Carga Horária: 54 Horas):
Clique aqui
Curso Gratuito de Fundamentos de Big Data (Carga Horária: 8 Horas): 
Clique aqui
Curso Gratuito de Python Fundamentos para Análise de Dados (Carga Horária: 54 Horas):
Clique aqui
Curso Gratuito de Introdução a Ciência de Dados (Carga Horária: 8 Horas):
Clique aqui
Curso Gratuito de Fundamentos de Inteligência Artificial (Carga Horária: 8 Horas): 
Clique aqui

Jupyter Notebook no Windows

Big Data No Comments

Introdução

Este post apresenta o Jupyter Notebook, uma aplicação Web, Open Source, que permite criar e compatilhar dados e resultados de análises, juntamente com o código.

Executando

Através do Anaconda, clique no botão “Launch” do Jupyter Notebook.

Abrirá o navegador padrão com a URL: http://localhost:8888/tree

Selecione “New” (canto direito) e escolha “Python 3”.

Teclas de Atalho

Shift+Enter: Executa o código fornecido na caixa “In [xx]”.

Alt+Enter: Insere uma nova linha de código (“In []”), abaixo da linha onde está o foco.

Instalando Jupyter no Windows

Big Data No Comments

Introdução

Este post tem o objetivo de demonstrar a instalação do Jupyter no Windows.

Pré-Requisitos

Para a instalação do Jupyter, precisamos do ambiente Python pronto.

Anaconda

Anaconda é uma plataforma Open Source para cientista de dados. Ela possui o R (linguagem de programação para estatística), o Python e módulos do Scala. O Anaconda para Windows pode ser baixado aqui.

Após a instalação, executar o Anaconda Navigator.

Path

Na instalação do Anaconda, recomenda-se não configurar o Path, automaticamente.

Neste caso, após a instalação é necessária a configuração na variável de ambiente, se deseja utilizar o prompt de comando.

  1. Localize “Meu Computador”, clique com o botão direito e selecione “Propriedades”
  2. Clique em “Configurações avançadas do sistema”
  3. Clique em “Variáveis de Ambiente…”
  4. Duplo clique em “Path”
  5. No final da linha acrescente (no meu caso, foi instalado para qualquer usuário):
    1. C:\ProgramData\Anaconda3\
    2. C:\ProgramData\Anaconda3\Library\bin
  6. Clique nos 3 botões “OK”
  7. Abra um promp de comando e digite:
    1. python (deverá abrir o editor do python – para sair, digite “quit()”

Anaconda Client

Para utilização do Anaconda Cloud, é necessário instalar o anaconda-client. Para isso, basta abrir um prompt de comando e digitar:

conda install anaconda-client

Executando o Jupyter

Com o Anaconda Navigator aberto, clique no botão “Launch” do componente Jupyter.

Abrirá no navegador padrão a seguinte URL: http://localhost:8888/tree

Cassandra no Docker e Java no Ubuntu

Big Data No Comments

Introdução

Este post tem por objetivo apresentar a utilização do Cassandra, rodando sob um container Docker e teste de integração com Java.

Pré-requisitos

Docker e ferramentas Java instalados

Dockerfile para o Cassandra

Para executar o Cassandra sob o container Docker, devemos criar o arquivo Dockerfile. Para este exemplo, criei no próprio diretório do projeto Maven.

Dockerfile

# Partir do docker inicial do cassandra no DockerHub
FROM cassandra:latest

Build do Dockerfile

  1. Entrar no diretório onde encontra-se o arquivo Dockerfile (no meu caso esta em /opt/workspaces/java-cassandra/Dockerfile)
  2. Executar o comando
    1. # docker build .
  3. Ao terminar o download e extração dos arquivos, digite o comando
    1. # docker images
      1. REPOSITORY    TAG         IMAGE ID                CREATED            SIZE
      2. cassandra           latest      0fb9df189322        2 weeks ago      323 MB
  4. Executar o comando para subir o docker da imagem gerada
    1. # docker run -it cassandra

Projeto Maven

Para facilitar, está disponível no Github o projeto para teste.

https://github.com/lfchaim/java-cassandra

 

Soluções Big Data

Big Data No Comments

Introdução

Este post tem a finalidade de apresentar as principais soluções de Big Data.

Integração

Talend

Talend é um ETL de código aberto, desenvolvido pela empresa francesa Talend. Ele permite que você crie graficamente manipulação de dados e processos de transformação e, em seguida, gere o executável correspondente como um programa Java.

Sqoop

Sqoop é um projeto da Fundação Apache, que visa permitir uma melhor coabitação de sistemas tradicionais de tipo DBMS com a plataforma Hadoop. Assim, é possível exportar dados do banco de dados e realizar processamento caro, explorando o cluster Hadoop. Os bancos de dados tradicionais são generalizados e o Sqoop permite que aplicativos tradicionais aproveitem um cluster Hadoop.

Mensagem

Kafka

Kafka é um sistema de mensagens distribuídas, desenvolvido originalmente pela equipe de Jay Kreps no LinkedIn, e publicado em 2011 como um projeto open source Apache.

Armazenagem

Redis

Redis é um repositório de dados de chave / valor criado pelo NoSQL e criado em 2009 por Salvatore Sanfilippo e Pieter Noordhuis. O projeto é patrocinado pela VMware e Pivotal.

Uma das principais características do Redis é manter todos os dados na memória. Isso proporciona um excelente desempenho, evitando o acesso ao disco, especialmente caro. Quando o tamanho dos dados é muito grande para manter a memória, o Redis também pode usar a memória virtual (swap).

Cassandra

Inicialmente desenvolvido pelo Facebook em 2008, foi lançado mais tarde e seu desenvolvimento agora é fornecido pela Fundação Apache. Datastax oferece suporte, bem como uma versão Enterprise com alguns recursos adicionais.

Cassandra é uma base de dados orientada a colunas. Estudou para implantações massivamente distribuídas (possivelmente em vários datacenters). Cassandra permite armazenar um elemento que é um conjunto de valores conectados entre si por um identificador exclusivo.

HBase

O HBase é um subprojeto do Hadoop, é um sistema de gerenciamento de banco de dados não-relacional distribuído, escrito em Java, com armazenamento estruturado para grandes tabelas.

HBase nasceu para fornecer acesso em tempo real a um cluster Hadoop. Ao contrário do HDFS, o acesso aos dados é aleatório e, portanto, mais eficiente, apesar da volumetria muito alta.

O Facebook no entanto, na origem de Cassandra, decidiu abandoná-lo em 2010 para o benefício da HBase.

O HBase é inspirado nas publicações do Google no BigTable, por isso é um banco de dados baseado em uma coluna e sem esquemas (em teoria). HBase está muito ligado ao Hadoop e o modo de cluster HDFS é necessário.

Cada valor de uma célula (campo no mundo relacional) é marcado com o tempo (como Cassandra), o que torna possível recuperar uma versão antiga do conteúdo.

HDFS

O HDFS é um sistema de arquivos Java usado para armazenar dados estruturados e não estruturados em um conjunto de servidores distribuídos.

O HDFS é um sistema de arquivos distribuído, extensível e portátil desenvolvido pela Hadoop a partir do sistema desenvolvido pelo Google (GoogleFS).

Escrito em Java, foi projetado para armazenar volumes de dados muito grandes em uma grande quantidade de máquinas equipadas com discos rígidos padrão.

A HDFS depende do sistema de arquivos do sistema operacional nativo para apresentar um sistema de armazenamento unificado baseado em um conjunto de sistemas de arquivos e arquivos heterogêneos.

MongoDB

MongoDB é um banco de dados orientado a documentos da mobilidade NoSQL que permite o armazenamento de documentos no formato BSON (uma forma binária de JSON). O seu idioma de consulta também está no formato JSON.

Possui mecanismos de replicação e fragmento para garantir resiliência e escalabilidade, mesmo que sua arquitetura seja mestre / secundária. Um mecanismo de eleição assegura a continuidade do serviço no caso de uma falha do mestre.

MongoDB é schemaless, o que significa que os documentos da mesma coleção não têm todos os mesmos campos.Os campos podem ser adicionados / removidos para um documento sem migração.

Neo4j

Neo4j é um dos mais antigos bases de dados NoSQL (primeira versão em 2000). É um banco de dados baseado em gráficos escrito em Java.

Os dados são armazenados no disco como uma estrutura de dados otimizada para redes gráficas.

Os bancos de dados orientados por gráfico são particularmente adequados em contextos onde os dados estão fortemente conectados e organizados de acordo com modelos complexos. A estrutura da entidade (nó ou relação) é definida no momento do armazenamento de dados (estrutura de schemaless), o que lhe confere uma grande flexibilidade.

Couchbase

O CouchBase é um banco de dados baseado em documento nascido em 2011, que é o resultado de dois projetos de código aberto: Membase (baseado em memcached) e Apache CouchDB com os quais ele continua compatível.

O CouchBase armazena documentos no formato JSon e oferece as seguintes formas de acessar dados:

  •  usando a chave exclusiva,
  •  através das visualizações (de dois tipos MapReduce / espaciais criados a partir de funções JavaScript),
  •  usando uma linguagem pseudo SQL (N1QL),
  •  através de pesquisa de texto completo.

Assim como o MongoDB, o formato JSon permite que o CouchBase seja simplificado, também é possível definir uma vida útil automática dos dados (TTL).

O CouchBase suporta o gerenciamento de vários datacenter no modo bidirecional.

Isso garante a continuidade do serviço em caso de indisponibilidade de um datacenter, mas também do usuário para consultar o datacenter mais próximo em operação normal.

O CouchBase fornece filtros de replicação que permitem que você selecione os dados para replicar entre dois centros de dados (somente versão corporativa).

Transformação

Spark

Spark nasceu em 2009 no laboratório AMPLab da Universidade de Berkeley na premissa de que:

  •  Por um lado, a memória custa menos e mais barata e os servidores, portanto, estão cada vez mais disponíveis.
  •  Por outro lado, muitos conjuntos de dados denominados “Dados grandes” têm um tamanho da ordem de 10 GB e, portanto, estão na memória.

Por isso, era necessário um sistema de tratamento que privilegie o processamento em memória dos dados.

O projeto se juntou à incubadora Apache em junho de 2013 e se tornou um projeto de nível superior em fevereiro de 2014.

O projeto foi progressivamente enriquecido para propor hoje um ecossistema completo.

O ecossistema da faísca agora inclui várias ferramentas:

  •  Spark para tratamentos “lote”
  •  Spark Streaming para o processamento contínuo de fluxos de dados
  •  MLlib para aprendizagem de máquinas, completado pela SparkML desde 2012
  •  GraphX ​​para cálculos de gráficos
  •  Spark SQL, uma implementação semelhante a SQL da consulta de dados.

Finalmente, o framework está escrito em Scala e oferece uma ligação Java que permite usá-lo sem problemas em Java. No entanto, o Java 8 é recomendado para explorar as expressões de lambdas que permitirão escrever um código mais funcional.

Existem versões específicas do Spark para Python e R para capitalizar as linguagens normalmente dominadas pelos Data Scientists.

MapReduce

MapReduce é uma estrutura de processamento paralelo, criada pelo Google para indexar o conteúdo de seu mecanismo de pesquisa na web. Disponível como um documento de pesquisa, sua primeira implementação apareceu no momento do desenvolvimento do Hadoop em 2005.

É uma estrutura que permite a decomposição de uma consulta importante em um conjunto de consultas menores que produzirão cada um um subconjunto do resultado final: esta é a função Map.

Todos os resultados são processados ​​(agregação, filtro): esta é a função Reduzir.

Em um processo MapReduce, diferentes atores irão intervir:

  •  Trabalhadores: lista de nós Hadoop que podem lidar com empregos MapReduce
  •  Mestre: um trabalhador dedicado ao gerenciamento de tarefas
  •  Cliente: lança o processamento MapReduce (muitas vezes chamado de driver)

As diferentes fases (Hadoop)

  1. Inicialização: o cliente / driver carrega um / mais arquivos no HDFS e envia um processamento MapReduce para a grade
  2. Split: os dados de entrada são opcionalmente divididos em blocos (16-64 MB)
  3. Atribuição: o mestre atribui as tarefas (Mapa e Redução) aos trabalhadores; a configuração define o número de tarefas Map e Reduce suportadas por cada um dos nós
  4. Mapa: leitura de divisões passadas para a função Map; Os conjuntos de chave / valor produzidos pela função são primeiro armazenados na memória antes de serem periodicamente escritos localmente e não em HDFS
  5. Shuffle: os resultados das funções Map são agregados pelo valor da chave para produzir uma lista de valores processados ​​pelo Reducer
  6. Reduzir: o mestre distribui para o Redutor a lista de dados a serem processados; os resultados são enviados para o fluxo de saída (HDFS, serviços web, …)
  7. Combinar: otimização, usa os resultados intermédios do mapa de entrada para um tratamento geralmente equivalente ao redutor (sem garantia de passagem)
  8. Fim: o mestre retorna ao programa do cliente

Flink

O Apache Flink é um projeto Apache de nível superior desde dezembro de 2014.

Anteriormente chamado Stratosphere e projeto de pesquisa da Data Artisans, foi criado em 2009 (como Spark).

O objetivo é fornecer uma estrutura de processamento distribuída em memória adaptada ao processamento em tempo real.

Diferenças com Spark:

  •  O Flink foi projetado desde o início por tempo real.
  •  Flink foi originalmente escrito em Java e suporta Scala com wrappers.
  •  O Flink pode realizar tratamentos Hadoop diretamente (ideal para uma transição suave).

O Flink inclui:

  •  APIs em Java / Scala para processamento em lote e em tempo real,
  •  Um mecanismo de transformação do programa em fluxos de dados paralelos,
  •  Um mecanismo de execução para distribuir processamento em um cluster.

Análise

Hive

Hive é um projeto iniciado pelo Facebook em 2008.

Como Pig, Hive permite a escrita de tarefas de processamento / consulta de dados para desenvolvedores que não conhecem o Java.

Onde Pig define uma linguagem processual para explorar o cluster, o Hive permite definir tabelas estruturadas do tipo SQL e alimentá-las com dados do cluster ou fontes externas.

Hive é baseado nas seguintes noções:

  •  Tabelas: uma tabela é uma sucessão de colunas e linhas, assim como para o mundo do SGBD. A diferença vem do sistema de armazenamento distribuído (HDFS ou outro). Outra diferença importante é a ausência de uma noção de chave primária.
  •  Partições: uma tabela do Hive pode ser particionada para distribuir dados no cluster (dependendo do valor de vários campos)
  •  Baldes: uma vez que particionado, os dados podem ser divididos em uma única coluna da tabela para dividir o armazenamento de dados. O Bucketing melhora o desempenho das juntas e permite que você trabalhe apenas em amostras.
  •  Metastore: este é o lugar onde a Hive armazena os metadados das tabelas (esquema, direitos de acesso, estatísticas, …)

Uma tabela Hive pode ser:

  •  internamente, os dados são duplicados em um diretório HDFS dedicado a Hive (armazém).
  •  externamente, os dados são armazenados em um diretório HDFS externo e somente os metadados são mantidos em Hive.

consultas

Uma vez que o esquema da tabela é definido e os dados inseridos, é possível usar a linguagem HiveQL para consultar essas tabelas. O HiveQL possui uma sintaxe próxima ao SQL e possibilita a realização das operações essenciais de leitura possibilitando a realização de análises clássicas (seleção de campos, soma, agregação, triagem, junção, …).

Pig

Pig é uma ferramenta de processamento de dados que faz parte do conjunto Hadoop e permite a escrita de scripts que são executados na infraestrutura Hadoop sem ter que passar pela escrita da tarefa em Java através da estrutura MapReduce. Ele também possui recursos para carregar dados de uma fonte externa para o cluster HDFS ou recursos para exportar dados para uso por aplicativos de terceiros.

Pig depende de sua própria língua chamada Pig Latin. Ele também fornece acesso à camada de aplicação Java. Esse idioma é bastante simples, o que permite que o desenvolvedor venha de um mundo diferente do Java para produzir scripts de processamento executados no Hadoop muito mais rapidamente.

Drill

O projeto Drill foi colocado na incubadora da Fundação Apache em agosto de 2012, é um mecanismo de consulta SQL para o Hadoop, desenvolvido inicialmente no MapR.

Inspirado no projeto Dremel do Google, o Drill permite consultas SQL interativas sobre o Hadoop, com o objetivo primordial de dar aos usuários não-desenvolvedores acesso a análises a partir de dados armazenados em HDFS e Hadoop.

Mesmo que a comparação não seja totalmente justa (a broca é como um Spark fácil de acessar), encontramos os mesmos casos de uso que o Hive.

Apache Impala

O Apache Impala é um mecanismo de consulta SQL de processamento massivamente paralelo de código aberto para dados armazenados em um cluster de computador que executa o Apache Hadoop. O Impala foi descrito como o equivalente ao código aberto do Google F1, que inspirou seu desenvolvimento em 2012.

 

Indexação

Elastic (Elasticsearch)

O ElasticSearch é um motor de busca aberto, distribuído e baseado em Lucene. Elasticsearch foi criado por Shay Banon, iniciador do projeto Compass, para substituir o último.

Ao contrário do Lucene, é um cluster de indexação, que depende de uma base de documento NoSQL interna usando o formato JSON para armazenamento de documentos. Além disso, exatamente como Solr e, ao contrário do Lucene, seu modo de consulta é de tipo cliente / servidor (não precisa ser implantado na mesma JVM que o cliente)

Os documentos são replicados para diferentes nós de armazenamento para melhorar o desempenho da pesquisa, mas também para gerenciar alta disponibilidade.

O papel da decomposição é o seguinte:

  •  Lucene gerencia operações de “baixo nível”, como indexação e armazenamento de dados,
  •  A pesquisa Elastic fornece várias camadas de abstração para aceitar o JSON, fornecendo uma API REST sobre HTTP e facilitando o clustering.

Ao contrário de alguns bancos de dados NoSQL, Elasticsearch não é esquemático. É possível indexar um documento sem qualquer informação sobre o seu formato (apenas os dados), mas o ElasticSearch criará um automaticamente a partir do formato de dados.

A pesquisa elástica está em constante evolução e, em desenvolvimentos recentes, deve-se notar:

  •  abandono do famoso sistema fluvial a favor de uma abordagem de tipo push por parte dos clientes,
  •  abandono de facetas em favor das agregações.

A linguagem de consulta é proprietária (Query DSL) e usa uma abordagem DSL e é baseada no formato JSon.

Ecossistema

Elastic, o editor da Elasticsearch, oferece um ecossistema cada vez mais rico em torno de seu mecanismo de busca.

Logstash

Logstash, permite coletar os logs, aplicar alguns tratamentos simples nas mensagens recebidas e depois transmiti-las a uma terceira solução, em particular, pesquisa Elastic para poder realizar pesquisas entre essas mensagens.

Kibana

A Kibana, outra solução bem conhecida, oferece uma interface gráfica para explorar e visualizar dados empurrados para o Elasticsearch ou aqueles armazenados em outras soluções além do editor.

Essas três soluções formam o trio mais comum para análise de log: ELK. Infelizmente, esses produtos tinham até recentemente um ciclo de vida independente que às vezes poderia levar a problemas de compatibilidade.

A nova embalagem foi renomeada como Elastic Stack. A Elastic Stack integra uma nova solução dedicada ao monitoramento, Beats, que é composto pelos seguintes produtos:

  •  PacketBeat: supervisão de rede,
  •  TopBeat: monitoramento de memória e CPU,
  •  FileBeat: supervisão de arquivos
  •  WinlogBeat: Monitoramento de eventos do sistema operacional (somente Windows),
  •  LibBeat: utilitários.

Aprendizagem

Spark ML e ML lib

MLlib

MLlib é um subprojeto Spark desde a versão 0.8. Como Spark, ele se originou no Berkeley Lab (AMPLab).

MLlib é a biblioteca de Aprendizagem de máquinas do Spark. Os algoritmos são projetados para aproveitar a computação paralela em um cluster Spark.

Por isso, é particularmente adaptado para volumetria elevada

MLlib, assim como o resto do framework Spark é desenvolvido em Scala. As operações de álgebra linear são baseadas nas bibliotecas Breeze e JBlas.

Algoritmos disponíveis:

  •  classificação: regressão logística, máquina de vetor de suporte linear (SVM), Bayes ingênuo,
  •  regressão: regressão linear generalizada (GLM)
  •  Filtragem colaborativa: alternando mínimos quadrados (ALS)
  •  agrupamento: k-means,
  •  decomposição: decomposição de valor singular (SVD), análise de componentes principais (PCA),
  •  dados escassos. (Dados escassos),
  •  Árvores de decisão (CART), Regressões Logísticas,
  •  Método Broyden-Fletcher-Goldfarb-Shanno (L-BFGS),
  •  avaliação modelo
  •  discretização.

Além de aproveitar o kernel Spark MLlib integra-se com:

  •  Spark SQL (DataFrames em entrada),
  •  Streaming (fluxo de previsão em tempo real),
  •  GraphX

Spark ML

Este subprojeto (disponível como pacote no Mllib desde a versão 1.5) é uma evolução para introduzir novos recursos (DataFrame, Pipeline) e padronizar APIs.

Mahout

Apache Mahout é um projeto da Fundação Apache desde 2011 com o objetivo de criar implementações de algoritmos de aprendizado de máquinas e mineração de dados.

Embora os principais algoritmos de aprendizagem sejam baseados no MapReduce, não existe a obrigação de usar o Hadoop.

O Apache Mahout foi projetado para funcionar sem essa dependência.

Precursor histórico, o Mahout enfrenta novas bibliotecas mais adaptadas aos algoritmos iterativos, como o MLlib da Spark (completado pela Spark ML), ou do mundo dos cientistas de dados, como o Scikit-learn ou o idioma R.

É por isso que, desde a versão 0.10.0 (abril de 2015), a Mahout usou Apache Spark e H2O (dependendo dos algoritmos).

Uma integração com o Flink está em andamento.

Este novo ambiente matemático é chamado Samsara.

Mahout-Samsara é um remake de Mahout para promover escalabilidade e desempenho, mas também fornecer uma tela para criar seus próprios algoritmos (desenvolvimento em Scala).

Samsara também oferece um shell interativo para lançar os tratamentos em um Spark cluster

O Mahout é muito rico em algoritmos de aprendizagem, agrupamento, classificação, filtragem colaborativa, análise de itens freqüentes, etc.

Clustering:

  •  K-means (paralelizável),
  •  Fuzzy K-means (paralelizável),
  •  K-means Spectral (paralelizável).

classificação:

  •  Regressão logística (não paralelizada),
  •  Naive Bayes (paralelizável),
  •  Floresta aleatória (paralelizada)
  •  Perceptron multicapa (não paralelizado).

Dimensionamento reduzido:

  •  Decomposição de valor singular (paralelizada)
  •  PCA (paralelizável),
  •  Decomposição Lanczos (paralelizada)
  •  Decomposição QR (paralelizada).

Texto:

  •  TF-IDF (paralelizável)

Akka

A Akka é uma estrutura para construir aplicativos concorrentes, distribuídos e resilientes com a JVM. A Akka é uma implementação orientada por ator que começou em 2009 por Jonas Boner e foi integrada pela primeira vez com a Scala.

A fonte de inspiração é a linguagem Erlang, que oferece uma arquitetura altamente competitiva e baseada em eventos. Akka agora é uma estrutura OpenSource suportada pelo TypeSafe (como Play e Scala), disponível tanto no Scala quanto no Java.

A programação por atores propõe os seguintes postulados:

Um ator é uma entidade que, após a recepção de um evento (mensagem) pode:

  •  enviar mensagens a outros atores
  •  criar novos atores,
  •  especifique o comportamento a seguir ao receber as mensagens que se seguem.

A execução dessas tarefas acima não está ordenada, para que elas possam ser paralelizadas.

O paradigma do ator dissocia o transmissor da mensagem da própria mensagem, permitindo assim o assincronismo das comunicações e a introdução de estruturas dedicadas ao gerenciamento das mensagens. Um ator deve conhecer o endereço do ator a quem ele deseja enviar uma mensagem. Os endereços podem ser trocados por mensagem.

Em resumo, um ator é:

  •  sistemas stateful,
  •  responde no recebimento de mensagens,
  •  envia mensagens aos atores:

> por nome ou endereço,

> em troca de receber uma mensagem,

> para um ator progenitor, …

Akka não é apenas uma implementação do modelo de ator:

  •  O apelido de transação que, no caso de um erro, permite cancelar as alterações e reiniciar o processo automaticamente.
  •  ordenou mensagens para um par transmissor / receptor.

Lista de estruturas construídas com Akka:

  •  Apache Spark,
  •  Gatling
  •  Fluxo Apache.

Akka, no entanto, tem os seguintes defeitos:

  •  processa as mensagens sequencialmente (mas podemos multiplicar o número de atores),
  •  nenhuma garantia de entrega / processamento de mensagens (entrega na maioria das vezes).

 

Java Redis Windows

Big Data No Comments

Introdução

Este post tem o objetivo de demonstrar como criar um ambiente com Redis e projeto Java, no Windows.

Redis no Windows

Primeiramente, o Redis não existe suporte para Windows. Para maiores detalhes, acesse https://redis.io/download.

Download Redis para Windows

Como não tive interesse em fazer o build, neste momento, resolvi encontrar alguma solução pronta.

Pesquisando no Google por “redis win64”, encontrei uma solução no link:

https://github.com/MSOpenTech/redis/releases/download/win-3.2.100/Redis-x64-3.2.100.msi

Esta solução instala o Redis como serviço no Windows, de forma rápida.

Criando o Projeto Java

Utilizei a IDE Eclipse, criando um projeto Quickstart Java, com Maven.

Também é possível baixar o projeto pronto, com algumas classes de teste implementadas em:

https://github.com/lfchaim/java-redis

Consulte também nosso canal no Facebook.

Instalar Apache Cassandra no Ubuntu

Big Data No Comments

Pre-Requisitos

Antes de instalar o Apache Cassandra em seu servidor, verifique se os seguintes pré-requisitos são atendidos:

  • A versão mais recente do Java 8, ou Oracle Java Standard Edition 8 ou OpenJDK 8 está instalado.
  • Se você estiver usando cqlsh , verifique se a versão mais recente do Python 2.7 está instalada em seu servidor.

Atualizando o Software no Ubuntu

Antes de tudo, conecte-se ao seu servidor Linux via SSH , atualize o índice do pacote e atualize todo o software instalado para a versão mais recente disponível. Você pode fazer isso usando os seguintes comandos:

sudo apt-get update
sudo apt-get upgrade

Instale o Java 8 no Ubuntu

Para instalar o Java 8 no seu Ubuntu 16.04 VPS, execute o seguinte comando:

sudo apt-get install default-jdk

Para verificar se o Java 8 está instalado, você pode usar:

java -version

A saída deve ser muito semelhante à seguinte:

openjdk version "1.8.0_131"
OpenJDK Runtime Environment (build 1.8.0_131-8u131-b11-0ubuntu1.16.04.2-b11)
OpenJDK 64-Bit Server VM (build 25.131-b11, mixed mode)

Instale o Apache Cassandra no Ubuntu

Para instalar o Apache Cassandra no seu servidor, primeiro você precisa adicionar o repositório Cassandra. No momento de escrever este tutorial, o último lançamento estável da Cassandra é 3.11.0.Portanto, execute o seguinte comando para adicionar o repositório Cassandra no seu servidor:

echo "deb http://www.apache.org/dist/cassandra/debian 311x main" | sudo tee -a /etc/apt/sources.list.d/cassandra.sources.list

Em seguida, adicione as chaves do repositório Cassandra:

curl https://www.apache.org/dist/cassandra/KEYS |  sudo apt-key add - 
sudo apt-key adv --keyserver pool.sks-keyservers.net --recv-key A278B781FE4B2BDA

Atualize o índice do pacote:

sudo apt-get update

Finalmente, instale o Apache Cassandra usando o seguinte comando:

sudo apt-get install cassandra

Iniciar, parar e ativar o Apache Cassandra no Ubuntu

Para iniciar o serviço Apache Cassandra em seu servidor, você pode usar o seguinte comando:

  sudo systemctl start cassandra.service

Para parar o serviço, você pode usar o comando abaixo:

  sudo systemctl stop cassandra.service

Se o serviço ainda não estiver habilitado na inicialização do sistema, você pode habilitá-lo usando o comando abaixo:

  sudo systemctl enable cassandra.service

O que é o seguinte?

Se você é novo no Apache Cassandra, recomenda-se que use a documentação oficial como ponto de partida. A documentação está disponível em http://cassandra.apache.org/doc/latest/ e irá ajudá-lo a aprender a configurar e usar o serviço para seus projetos.

Spark

Big Data No Comments

O que é o Spark

O Spark é um framework para processamento de Big Data construído com foco em velocidade, facilidade de uso e análises sofisticadas. Está sendo desenvolvido desde de 2009 pelo AMPLab da Universidade de Califórnia em Berkeley e em 2010 seu código foi aberto como projeto da fundação Apache.

O Spark tem muitas vantagens se comparado as outras tecnologias de Big Data e do paradigma MapReduce, como o Hadoop e o Storm.

Inicialmente, o Spark oferece um framework unificado e de fácil compreensão para gerenciar e processar Big Data com uma variedade de conjuntos de dados de diversas naturezas (por exemplo: texto, grafos, etc), bem como de diferentes origens (batch ou streaming de dados em tempo real).

O Spark permite que aplicações em clusters Hadoop executem até 100 vezes mais rápido em memória e até 10 vezes mais rápido em disco, desenvolver rapidamente aplicações em Java, Scala ou Python. Além disso, vem com um conjunto integrado de mais de 80 operadores de alto nível e pode ser usado de forma interativa para consultar dados diretamente do console.

Além das operações de Map/Reduce, suporta consultas SQL, streaming de dados, aprendizado de máquina e processamento de grafos. Desenvolvedores podem usar esses recursos no modo stand-alone ou combiná-los em um único pipeline.

Nesta primeira edição dessa série de artigos sobre o Apache Spark, veremos o que é o Spark, como ele se compara com uma solução típica com MapReduce e disponibiliza um conjunto completo de ferramentas para processamento de Big Data.

Hadoop e Spark

O Hadoop já existe a mais de 10 anos e tem provado ser a melhor solução para o processamento de grandes conjuntos de dados. O MapReduce, é uma ótima solução para cálculos de único processamento, mas não muito eficiente para os casos de uso que requerem cálculos e algoritmos com várias execuções. Isso porque cada etapa no fluxo de processamento tem apenas uma fase Map e uma fase Reduce e, desse modo é necessário converter qualquer caso de uso para o padrão MapReduce para chegar a uma solução.

Os dados de saída do processamento de cada etapa devem ser armazenados no sistema de arquivo distribuídos antes do passo seguinte começar. Assim, esta abordagem tende a ser lenta devido à replicação e armazenamento em disco. Além disso, as soluções Hadoop incluem tipicamente clusters que são difíceis de configurar e gerenciar, além de precisar da integração de várias ferramentas para diferentes casos de uso de Big Data (como o Mahout para Aprendizado de Máquina e o Storm para o processamento de streaming).

Nesse cenário, caso seja necessário fazer algo complexo, seria preciso encadear uma série de jobs de MapReduce e executá-los em sequência. Cada um desses jobs terão alta latência e não poderá começar até que o anterior tenha terminado.

O Spark permite que os programadores desenvolvem pipelines compostos por várias etapas complexas usando grafos direcionais acíclicos. Além disso, suporta o compartilhamento de dados da memória através desses grafos, de modo que os diferentes jobs possam trabalhar com os mesmos dados.

O Spark usa a infraestrutura do Hadoop Distributed File System (HDFS), mas melhora suas funcionalidades e fornece ferramentas adicionais. Por exemplo, permite a implantação de aplicativos em cluster Hadoop v1 (com SIMR – Spark Inside MapReduce), ou em Hadoop v2 com YARN ou com Apache Mesos.

Devemos olhar para o Spark como uma alternativa para MapReduce do Hadoop em vez de um simples substituto, mas como uma solução abrangente e unificada para gerenciar diferentes casos de uso da Big Data.

Características do Spark

O Spark estende o MapReduce evitando mover os dados durante seu processamento, através de recursos como armazenamento de dados em memoria e processamento próximo ao tempo real, o desempenho pode ser várias vezes mais rápido do que outras tecnologias de Big Data.

Também há suporte para validação sob demanda de consultas para Big Data, o que ajuda com a otimização do fluxo de processamento de dados e fornece uma API de mais alto nível para melhorar a produtividade do desenvolvedor e um modelo consistente para o arquiteto de soluções Big Data.

O Spark detém resultados intermediários na memória, em vez de escrevê-los no disco, o que é muito útil quando se precisa processar o mesmo conjuntos de dados muitas vezes. Seu projeto teve por objetivo torná-lo um mecanismo de execução que funciona tanto na memória como em disco e, por isso, o Spark executa operações em disco quando os dados não cabem mais na memória. Assim, é possível usá-lo para o processamento de conjuntos de dados maiores que a memória agregada em um cluster.

O Spark armazenará a maior quantidade possível de dados na memória e, em seguida, irá persisti-los em disco. Cabe ao arquiteto do sistema olhar para os seus dados e casos de uso para avaliar os requisitos de memória. Com esse mecanismo de armazenamento de dados em memória, o uso do Spark traz vantagens de desempenho.

Outras características do Spark:

  • Suporta mais do que apenas as funções de Map e Reduce;
  • Otimiza o uso de operadores de grafos arbitrários;
  • Avaliação sob demanda de consultas de Big Data contribui com a otimização do fluxo global do processamento de dados;
  • Fornece APIs concisas e consistentes em Scala, Java e Python;
  • Oferece shell interativo para Scala e Python. O shell ainda não está disponível em Java.

O Spark é escrito na linguagem Scala e executa em uma máquina virtual Java. Atualmente, suporta as seguintes linguagens para o desenvolvimento de aplicativos:

  • Scala
  • Java
  • Python
  • Clojure
  • R

O ecossistema do Spark

Além da API do Spark, existem bibliotecas adicionais que fazem parte do seu ecossistema e fornecem capacidades adicionais para as áreas de análise de Big Data e aprendizado de máquina.

Estas bibliotecas incluem:

  • Spark Streaming:
    • O Spark Streaming pode ser usado para processar dados de streaming em tempo real baseado na computação de microbatch. Para isso é utilizado o DStream que é basicamente uma série de RDD para processar os dados em tempo real;
  • Spark SQL:
    • Spark SQL fornece a capacidade de expor os conjuntos de dados Spark através de uma API JDBC. Isso permite executar consultas no estilo SQL sobre esses dados usando ferramentas tradicionais de BI e de visualização. Além disso, também permite que os usuários usem ETL para extrair seus dados em diferentes formatos (como JSON, Parquet, ou um banco de dados), transformá-los e expô-los para consultas ad-hoc;
  • Spark MLlib:
    • MLlib é a biblioteca de aprendizado de máquina do Spark, que consiste em algoritmos de aprendizagem, incluindo a classificação, regressão, clustering, filtragem colaborativa e redução de dimensionalidade;
  • Spark GraphX:
    • GraphX ​​é uma nova API do Spark para grafos e computação paralela. Em alto nível, o GraphX ​​estende o Spark RDD para grafos. Para apoiar a computação de grafos, o GraphX ​​expõe um conjunto de operadores fundamentais (por exemplo, subgrafos e vértices adjacentes), bem como uma variante optimizada do Pregel. Além disso, o GraphX ​​inclui uma crescente coleção de algoritmos para simplificar tarefas de análise de grafos.

Além destas bibliotecas, outros componentes completam o ecossistema do Spark, como o BlinkDB e o Tachyon.

O BlinkDB é uma engine SQL para consultas por amostragem e pode ser usado para a execução de consultas interativas em grandes volumes de dados. Permite que os usuários equilibrem a precisão de consulta com o tempo de resposta. Além disso, o BlinkDB funciona em grandes conjuntos de dados, através de amostragem de dados e apresentação de resultados anotados com os valores de erros.

O Tachyon é um sistema de arquivos distribuídos em memória que permite o compartilhamento de arquivos de forma confiável e rápida através de frameworks de cluster, como Spark e MapReduce. Também armazena em cache os arquivos que estão sendo trabalhados, permitindo que a existência de diferentes processamentos / consultas e enquadramentos para acessar arquivos em cache na velocidade de memória.

Finalmente, há também adaptadores de integração com outros produtos, como Cassandra (Cassandra Spark Connector) e R (SparkR). Com o Cassandra Connector, é possível usar o Spark para acessar dados armazenados no banco de dados Cassandra e realizar com o R análises estatísticas.

O diagrama a seguir (Figura 1) mostra como as diferentes bibliotecas do ecossistema Spark estão relacionados uns com os outros.

Figura 1. Bibliotecas do Framework Spark.

Vamos explorar todas essas bibliotecas nos próximos artigos desta série.

A arquitetura do Spark

A arquitetura Spark inclui os seguintes componentes:

  • Armazenamento de dados;
  • API;
  • Framework de gerenciamento.

Vejamos cada um desses componentes em detalhes.

Armazenamento de dados:

O Spark usa sistema de arquivos HDFS para armazenamento de dados. Funciona com qualquer fonte de dados compatível com Hadoop, incluindo o próprio HDFS, HBase, Cassandra, etc.

API:

A API permite que os desenvolvedores de aplicações criem aplicações baseadas no Spark usando uma interface de API padrão para Scala, Java e Python.

A seguir, estão os links dos site da API Spark para as linguagens: Scala, Java e Python

Gestão de recursos:

O Spark pode ser implantado como um servidor autônomo ou em uma estrutura de computação distribuída como o Mesos ou o YARN. Na Figura 2, apresentam-se os componentes da arquitetura Spark.

Figura 2. Arquitetura do Spark.

Conjunto de dados resilientes e distribuídos

O conjunto de dados resilientes e distribuídos (base do trabalho de pesquisa de Matei Zaharia) ou RDD (Resilient Distributed Datasets) é o conceito central do framework Spark. Imagine o RDD como uma tabela do banco de dados que pode guardar qualquer tipo de dado. O Spark armazena os dados do RDD em diferentes partições. Isso ajuda a reorganização computacional e a otimização no processamento dos dados.

Os RDDs são imutáveis. Ainda que aparentemente seja possível modificar um RDD com uma transformação, na verdade o resultado dessa transformação é um novo RDD, sendo que o original permanece intocável.

O RDD suporta dois tipos de operações:

Transformação: Não retornam um único valor, mas um novo RDD. Nada é avaliado quando a função de transformação é chamada, ela apenas recebe um RDD e retorna um novo RDD.

Algumas das funções de transformação são map, filter, flatMap, groupByKey, reduceByKey, aggregateByKey, pipe e coalesce.

Ação: Esta operação avalia e retorna um novo valor. Quando uma função de ação é chamado em um objeto RDD, todas as consultas de processamento de dados são computadas e o valor é retornado. Algumas das operações de ação são reduce, collect, count, first, take, countByKey e foreach.

Como instalar o Spark

Existem algumas maneiras de instalar e usar Spark: É possível instalá-lo em sua máquina para execução stand-alone ou usar uma máquina virtual (VM) disponibilizadas por fornecedores como Cloudera, Hortonworks ou MapR. Ou também é possível utilizar um Spark instalado e configurado na nuvem (como na Databricks Cloud).

Neste artigo, vamos instalar Spark como um framework stand-alone e executá-lo localmente. Vamos usar a versão 1.2.0 para o código da aplicação exemplo.

Como executar o Spark

Durante a instalação do Spark em máquina local ou na nuvem, existem diferentes maneiras nas quais é possível acessar o engine do Spark.

A tabela a seguir mostra como configurar o parâmetro Master URL para diferentes modos de funcionamento do Spark.

Como interagir com o Spark

Uma vez que o Spark esteja instalado e funcionando, é possível conectar nele usando um shell para análise interativa dos dados. O Spark Shell está disponível em Scala e Python.

Para acessá-los, execute respectivamente os comandos spark-shell.cmd e pyspark.cmd.

Console Web do Spark

Independente do modo de execução, é possível visualizar os resultados e outras estatísticas através do Web Console disponível na URL:

http://localhost:4040

O Console do Spark é mostrado na Figura 3 a seguir com abas para Stages, Storage, Ecosystem e Executor.

(Clique na imagem para ampliá-la)

Figura 3. Console Web do Spark.

Variáveis ​​compartilhadas

O Spark oferece dois tipos de variáveis ​​compartilhadas para torná-lo eficiente para execução em cluster. Estas variáveis ​são dos tipos Broadcast e Acumuladores.

Broadcast: ou variáveis ​​de difusão, permitem manter variáveis somente leitura no cache de cada máquina em vez de enviar uma cópia junto com as tarefas. Essas variáveis podem ser usadas ​​para dar aos nós do cluster as cópias de grandes conjuntos de dados.

O seguinte trecho de código mostra como usar as variáveis ​​de broadcast.

//
// Variáveis de Broadcast
//
val broadcastVar = sc.broadcast(Array(1, 2, 3))
broadcastVar.value

Acumuladores: permitem a criação de contadores ou armazenar os resultados de somas. As tarefas em execução no cluster podem adicionar valores à variável do acumulador usando o método add. No entanto, as tarefas distintas não podem ler o seu valor pois apenas o programa principal pode ler o valor de um acumulador.

O trecho de código a seguir mostra como usar criar um acumulador:

//
// Acumulador
//
val accum = sc.accumulator(0, "My Accumulator")
sc.parallelize(Array(1, 2, 3, 4)).foreach(x => accum += x)
accum.value

Amostra de uma Aplicação do Spark

A aplicação de exemplo deste artigo é um aplicativo de contagem simples de palavras. Este é o mesmo exemplo apresentado em muitos tutoriais sobre o Hadoop. Vamos realizar algumas consultas de análise de dados em um arquivo de texto. Esse arquivo e o conjunto de dados desse exemplo são pequenos, mas as mesmas consultas Spark podem ser usadas para grandes conjuntos de dados sem quaisquer modificações no código.

Para facilitar a apresentação, usaremos o shell de comandos para Scala.

Primeiramente, veremos como instalar Spark em sua máquina local.

Pré-requisitos:

  • Será necessário instalar o Java Development Kit (JDK) para trabalhar localmente. A instalação da JDK é coberta no Etapa 1 a seguir.
  • Também precisar instalar o software do Spark na sua máquina local. As instruções sobre como fazer isso são abordadas na Etapa 2 a seguir.

Nota: Estas instruções estão preparadas para ambiente o Windows. Se estiver usando um sistema operacional diferente, será necessário modificar as variáveis ​​do sistema e caminhos de diretório de acordo com seu ambiente.

I. Instalar o JDK:

1) Faça download do JDK no site Oracle. A versão 1.7 do JDK é a recomendada.

Instale o JDK em um diretório sem espaços. Isto é, para usuários do Windows, instale o JDK em uma pasta similar a “C:\dev”, e não em “C:\Arquivos de Programas”. O diretório “Arquivos de Programas” tem um espaço no nome e isso pode causar problemas quando o software é instalado nesta pasta.

Nota: Não instale o JDK ou o Spark (descrito na Etapa 2) em “C:\Arquivos de Programas”.

2) Depois de instalar o JDK, verifique se ele foi instalado corretamente navegando via prompt até a pasta “bin” dentro do diretório do JDK 1.7 e digitando o seguinte comando:

java -version

Se o JDK está instalado corretamente, o comando exibirá a versão instalada do Java.

II. Instalar o software do Spark:

Baixe a versão mais recente do Spark. A versão mais recente no momento da escrita deste artigo é Spark 1.2. É possível escolher uma instalação Spark específico, dependendo da versão do Hadoop. Baixei Spark para Hadoop 2.4 ou posterior, cujo nome do arquivo é spark-1.2.0-bin hadoop2.4.tgz.

Descompacte o arquivo de instalação em um diretório local (por exemplo: “C:\dev”).

Para verificar a instalação o Spark, navegue até o diretório e execute o shell do Spark utilizando os comandos a seguir. Isto é para Windows. Se estiver usando Linux ou Mac OS, edite os comandos para trabalhar em seu sistema operacional.

c:
cd c:\dev\spark-1.2.0-bin-hadoop2.4
bin\spark-shell

Se o Spark foi instalado corretamente, será apresentado as seguintes mensagens na saída no console.

….
15/01/17 23:17:46 INFO HttpServer: Starting HTTP Server
15/01/17 23:17:46 INFO Utils: Successfully started service 'HTTP class server' on port 58132.
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 1.2.0
      /_/

Using Scala version 2.10.4 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_71)
Type in expressions to have them evaluated.
Type :help for more information.
….
15/01/17 23:17:53 INFO BlockManagerMaster: Registered BlockManager
15/01/17 23:17:53 INFO SparkILoop: Created spark context..
Spark context available as sc.

Digitar os seguintes comandos para verificar se o Spark está funcionando corretamente:

sc.version

(ou)

sc.appName

Após esta etapa, pode sair da janela de shell do Spark digitando o seguinte comando:

:quit

Para iniciar o shell do Spark Python é preciso ter o Python instalado em sua máquina. Sugerimos o download e instalação do Anaconda, que é uma distribuição Python livre e inclui vários pacotes Python populares para matemática, engenharia e análise de dados.

Em seguida, execute os seguintes comandos:

c:
cd c:\dev\spark-1.2.0-bin-hadoop2.4
bin\pyspark

Aplicação Word Count

Uma vez que já tem o Spark instalado e funcionando, podemos executar as consultas de análise de dados usando API do Spark.

A seguir temos alguns comandos simples para ler os dados de um arquivo e processá-los. Vamos trabalhar com casos de uso avançados nos próximos artigos desta série.

Primeiro, vamos usar API Spark para realizar a contagem das palavras mais populares no texto. Abra uma nova shell do Spark e execute os seguintes comandos:

import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._

val txtFile = "README.md"
val txtData = sc.textFile(txtFile)
txtData.cache()

Chamamos a função de cache para armazenar o RDD criado no passo anterior, então o Spark não tem de computá-lo em cada uso nas consultas posteriores. Note que cache() é uma operação lazy, portanto o Spark não armazena imediatamente os dados na memória. Na verdade, só será alocado se uma ação for chamada no RDD.

txtData.count()

Agora, podemos chamar a função contagem para ver quantas linhas existem no arquivo de texto.

val wcData = txtData.flatMap(l => l.split(" ")).map(word => (word, 1)).reduceByKey(_ + _)

wcData.collect().foreach(println)

Se quiser ver mais exemplos de códigos de uso Spark API Core, verifique a documentação Spark em seu site.