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.

Instalando Redis Desktop Manager no Ubuntu

DevOps No Comments

Introdução

Neste post, apresentamos a instalação do Redis Desktop Manager, versão 0.9, no Ubuntu 16.04.

Procedimento

Baixar fontes no Git

$ git clone –recursive https://github.com/uglide/RedisDesktopManager.git -b 0.9 rdm && cd ./rdm

Configurando Make

$ cd src

$ ./configure

Fazendo Make

$ source /opt/qt59/bin/qt59-env.sh && qmake && make && sudo make install

Rodando RDM

$ cd /usr/share/redis-desktop-manager/bin

$ mv qt.conf qt.backup

$ ./rdm

ou

$ redis-desktop-manager

 

Instalando Redis no Ubuntu

DevOps No Comments

Introdução

Este post apresenta como instalar o Redis no Ubuntu, facilmente.

Procedimento

Atualizar biblioteca

$ sudo apt-get update

Obter o Redis

$ sudo apt-get install redis-server

Subir o servidor

$ redis-server /etc/redis/redis.conf

Verificar servidor

$ ps -ef| grep redis

ou

$ redis-cli

Baixar o servidor

$ /etc/init.d/redis-server stop

 

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.

Instalando Python no Ubuntu

Python No Comments

Introdução

Vamos mostrar-lhe, como instalar pip no Ubuntu 16.04. Pip é um sistema de gerenciamento de pacotes usado para instalar e gerenciar pacotes de software escritos em Python, que podem ser encontrados no Python Package Index (PyPI) .

Pip tem um recurso para gerenciar listas completas de pacotes e números de versão correspondentes, possíveis através de um arquivo “requisitos”. Instalar Pip no Ubuntu 16.04, é uma tarefa fácil, siga cuidadosamente as etapas deste tutorial e você deve ter o Pip instalado no Ubuntu 16.04, em menos de 10 minutos.

Atualização do Sistema

sudo apt-get update && sudo apt-get -y upgrade

Instalando Pip

sudo apt-get install python-pip

Verificando a instalação

O gerenciador de pacotes apt instalará o Pip e todas as dependências necessárias para que o software funcione de forma otimizada. Uma vez concluída a instalação, você pode verificar se foi bem-sucedido usando o seguinte comando.

pip -V

Procurando pacote com Pip

pip install package_name

Desinstalando pacote com Pip

pip uninstall package_name

Mais comandos

Para mais comandos, utilize a opção –help

# pip --help

Usage:
  pip <command> [options]

Commands:
  install                     Install packages.
  download                    Download packages.
  uninstall                   Uninstall packages.
  freeze                      Output installed packages in requirements format.
  list                        List installed packages.
  show                        Show information about installed packages.
  search                      Search PyPI for packages.
  wheel                       Build wheels from your requirements.
  hash                        Compute hashes of package archives.
  completion                  A helper command used for command completion
  help                        Show help for commands.

General Options:
  -h, --help                  Show help.
  --isolated                  Run pip in an isolated mode, ignoring environment variables and user configuration.
  -v, --verbose               Give more output. Option is additive, and can be used up to 3 times.
  -V, --version               Show version and exit.
  -q, --quiet                 Give less output.
  --log                 Path to a verbose appending log.
  --proxy              Specify a proxy in the form [user:passwd@]proxy.server:port.
  --retries          Maximum number of retries each connection should attempt (default 5 times).
  --timeout              Set the socket timeout (default 15 seconds).
  --exists-action     Default action when a path already exists: (s)witch, (i)gnore, (w)ipe, (b)ackup.
  --trusted-host    Mark this host as trusted, even though it does not have valid or any HTTPS.
  --cert                Path to alternate CA bundle.
  --client-cert         Path to SSL client certificate, a single file containing the private key and the certificate in PEM format.

 

Docker – Spring Data REST e H2

Docker No Comments

Introdução

Este post tem por objetivo, incluir a aplicação Spring Data REST e H2 sob o container Docker.

Premissa

Procedimento

Com a aplicação importada em sua IDE de preferência, crie o arquivo Dockerfile (sem extensão) na raiz do projeto.

IMPORTANTE: O arquivo deve ser criado com a primeira letra maiúscula e o restante minúscula (Dockerfile). Se não for respeitado o nome, não funcionará.

Dockerfile

FROM java:8
VOLUME /tmp
ADD target/spring-rest-data-h2-1.0.0.jar app.jar
ENTRYPOINT [ "sh", "-c", "java -Djava.security.egd=file:/dev/./urandom -jar /app.jar" ]

Prompt de Comando (Terminal)

# docker build .

Aguarde todo o processo de download e instalação.

# docker images

Mostrará a imagem criada, conforme o arquivo de configuração (ex: java:8).

# docker build -t java:8 .

Identificará o REPOSITORY e TAG.

# docker run -it -p 8000:8080 java:8

Isso fará subir a imagem (java:8) sob a porta local 8000 e porta no container 8080. Perceba também que já subirá sua aplicação Spring Boot (java -jar /app.jar).

Agora, basta abrir um navegador na máquina e digitar:

http://localhost:8000

Whitelabel Error Page

This application has no explicit mapping for /error, so you are seeing this as a fallback.

Wed Jan 17 22:28:41 UTC 2018
There was an unexpected error (type=Not Found, status=404).
No message available
Sob a URL http://localhost:8000/user/list

[]

Aparecerá 2 colchetes, informando que o banco de usuários está vazio.
Pronto! Sua aplicação agora, está rodando sob o container Docker.
# CTRL + p + q (sairá do container, mas continuará rodando)
# docker stats [[CONTAINER_ID]] (apresentará o consumo de CPU, Memória e IO)

CONTAINER    CPU % MEM USAGE / LIMIT     MEM % NET I/O          BLOCK I/O    PIDS
bbcf887896ac 0.09% 326.9MiB /  3.659GiB  8.72% 26.4kB / 4.44kB  90.2MB / 0B  34

# docker stop bbcf887896ac (baixará o container)

# docker start

Remover todas as imagens (CUIDADO)

# docker rmi $(docker images -q)

Docker no Ubuntu – Dockerfile

Docker No Comments

Introdução

Objetivo desse post é apresentar o Dockerfile, um arquivo de configuração para montar uma imagem, através de passos de comandos.

How to

# mkdir dockerfile

# cd dockerfile

# mkdir apache (OBS: só pode existir um arquivo Dockerfile no diretório, por isso criamos a pasta apache)

# cd apache

# touch Dockerfile

# vi Dockerfile

FROM ubuntu:17.10
MAINTAINER lfchaim@gmail.com
RUN apt-get update && apt-get install -y apache2 && apt-get clean

# docker build .

# docker images

REPOSITORY   TAG      IMAGE ID       CREATED         SIZE
<none>       <none>   142f04da6a70   2 minutes ago   229MB

ATENÇÃO: Veja que os campos REPOSITORY e TAG não estão preenchidos. Para preenchê-los, digite.

# docker build -t ubuntu/apache:1.0 .

OBS: ubuntu/apache é o nome do REPOSITORY que desejamos criar e 1.0 a TAG.

# docker images

REPOSITORY     TAG IMAGE ID       CREATED        SIZE
ubuntu/apache  1.0 142f04da6a70   6 minutes ago  229MB

# docker run -it ubuntu/apache:1.0 /bin/bash

# ps -ef

# /etc/init.d/apache2 start

# ps -ef

Saia do Container

# CTRL + p + q

# docker inspect 13fde0c3d9e4

Pegar o IP do Container e digitar.

# curl 172.17.0.2

Pronto, a imagem foi criada conforme o Dockerfile!

Docker no Ubuntu

Docker No Comments

Introdução

O objetivo desse post é aprender a utilização do Docker no Ubuntu.

Instalação

Verificar versão do Kernel

Esse comando serve para validar a versão do Kernel. Esta versão deverá ser superior a 3.8.

# uname -r

Instalando o Docker

# curl -sSL https://get.docker.com | sh

Subindo o Docker

# /etc/init.d/docker start

Verificando se o Docker está no ar

# docker ps

Ou

# ps -ef | grep docker

Rodando uma imagem

Verificando as imagens

# docker images

Rodando e instalando o Ubuntu

Rodando o comando abaixo, na primeira vez, será baixado o Ubuntu, na versão informada.

# docker run -i -t ubuntu:17.10 /bin/bash

Ao final do processo, o Container será iniciado, sendo possível verificar que mudou o prompt do console.

Exemplo: root@6d9436afdb02:/#

Matando o Container

# CTRL + d

ATENÇÃO: Esse comando fará com que o Container encerre. Não será mais possível executá-lo. Quaiques modificações e/ou instalações serão PERDIDAS!

Sair do Container sem encerrar.

root@6d9436afdb02:/# CTRL + p + q (control + p + q)

# docker ps (verifique que o processo continua rodando)

Voltando para o Container

# docker ps

# docker attach [[CONTAINER_ID]]

Exemplo:

root@CCE:/home/fernando# docker attach 6d9436afdb02
root@6d9436afdb02:/#

Instalando ferramentas / aplicativos

NGinx

  • Crie o Container – # docker run -i -t -p 8080:80 ubuntu:17.10 /bin/bash
    • Redirecionando a porta 8080 fora do Container, na porta 80 (dentro do Container)
  • Instale o NGinx – # apt-get install nginx
    • Caso falhe – # apt-get update
  • /etc/init.d/nginx start
  • Abra um navegador e digite: http://localhost:8080

Verificando instalações efetuadas no Container

Fora do Container, digite

# docker diff [[CONTAINER_ID]]

Salvando o Container modificado

Podemos gerar uma imagem, fazendo o commit.

# docker commit [[CONTAINER_ID]] [[NOME_DA_IMAGEM:[[VERSAO]]

Exemplo:

# docker commit bae5725fbdc2 nginx-ubuntu:1.0

# docker images

Subindo novo Container com base na imagem

# docker run -i -t -p 6660:80 nginx-ubuntu:1.0 /bin/bash

Agora, temos 2 containers respondendo na porta 8080 e 6660.

Parando um Container fora dele

# docker stop [[CONTAINER_ID]]

Rodando comandos fora do container

Preparação

# docker images

REPOSITORY TAG IMAGE ID CREATED SIZE
badtux/nginx-ubuntu 1.0 004a02a614ec 22 hours ago 192MB
ubuntu 17.10 26d147d2310f 25 hours ago 96.6MB

# docker run -ti -p 8080:80 badtux/nginx-ubuntu:1.0 /bin/bash

# /etc/init.d/nginx start

# CTRL + p + q

# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c0907ccd5120 badtux/nginx-ubuntu:1.0 “/bin/bash” 49 seconds ago Up 46 seconds 0.0.0.0:8080->80/tcp friendly_heisenb

# docker exec c0907ccd5120 ps -ef

UID PID PPID C STIME TTY TIME CMD
root 1 0 0 22:13 ? 00:00:00 /bin/bash
root 31 1 0 22:13 ? 00:00:00 nginx: master process /usr/sbin/nginx
www-data 32 31 0 22:13 ? 00:00:00 nginx: worker process
www-data 33 31 0 22:13 ? 00:00:00 nginx: worker process
www-data 34 31 0 22:13 ? 00:00:00 nginx: worker process
www-data 35 31 0 22:13 ? 00:00:00 nginx: worker process
root 38 0 0 22:14 ? 00:00:00 ps -ef

# docker exec c0907ccd5120 /etc/init.d/nginx stop

Verificando as informações do Container

# docker inspect c0907ccd5120

Mostra uma série de informações como o IP do Container, Porta do Container, quando foi criado, etc.

#docker stats

Mostra um resumo do Container em relação a consumo de CPU, Memória e Rede.

# docker stop c0907ccd5120

# docker ps

# docker start c0907ccd5120

# docker rm c0907ccd5120 (ATENÇÃO: remove o Container e não será possível utilizá-lo mais)

Removendo a Imagem

# docker images

# docker rmi [[IMAGE_ID]]

# docker rmi -f [[IMAGE_ID]]

Comunicação entre containers

# docker run -it –name web02 –link friendly_heisenb:web01 badtux/nginx-ubuntu:1.0

# ping web01

Criando Dockerfile

Aguarde!

Inbound Marketing para imobiliárias

Marketing No Comments

Desde 2010, o mercado imobiliário no Brasil sofre com uma queda no número de vendas que gera consequência em toda a cadeia – segundo dados da Folha de S. Pauloo número de empregos no setor é o mais baixo desde 2008. O cenário desde então não vem apresentando melhoras. A retração do setor chegou a mais de 30% em outubro de 2015, de acordo com a Embraesp (Empresa Brasileira de Estudos de Patrimônio).

Como as expectativas não são boas, muitas empresas encontraram um caminho sem volta: fechar as portas. Para as construtoras e imobiliárias que permaneceram no mercado, a queda na concorrência contribui para a melhoria da situação. Além disso, a busca por alternativas também tem mantido empresas de portas abertas.

Estratégias diferenciadas

Apesar da crise ter desestruturado diversas construtoras, existem imobiliárias que estão conseguindo manter o crescimento – ou pelo menos evitando a retração. Para isso, foi necessário investir em diferentes tipos de estratégias. Foi nesse momento que o Inbound Marketing ganhou espaço no segmento imobiliário.

A primeira vantagem encontrada é a redução de custos com marketing. Por exemplo, para realizar uma publicação de uma página aos domingos (dia com maior circulação) em jornal impresso na região de São Paulo Capital (impacto médio de 320 mil pessoas), o investimento gira em torno de R$440 mil. No digital, esse investimento cai pra R$6 mil (saiba mais aqui).

Além do custo reduzido, o Inbound Marketing permite que seja feita a mensuração de resultados com precisão – sabemos exatamente quantas pessoas clicaram em um anúncio no Google. Por outro lado, não conseguimos medir quantas pessoas foram impactadas por um outdoor, por exemplo.

Inbound Marketing Imobiliário

Com cada vez mais adeptos, é importante mantermos um alinhamento comum sobre como é a atuação do Inbound para imobiliárias, pois existe uma limitação. A forma mais simples de explicar é pensar que uma imobiliária não funciona como um ecommerce. Não conseguimos gerar toda a venda pela internet porque o ticket é muito alto e a venda é complexa. Existem muitas variáveis que influenciam a venda, que vão desde o trabalho do corretor até a aprovação de financiamento em banco, que depende de muitos fatores.

Entretanto, mesmo que o Inbound Marketing imobiliário não seja feito 100% online, as estratégias facilitam a venda e a tornam mais rápida, uma vez que os prospects abordados estão muito mais perto do momento da compra. Por isso, separamos neste post 4 dicas práticas para iniciar um planejamento de Marketing Digital para uma construtora ou imobiliária.

1- Qualificação de Leads

Todo corretor, imobiliária ou construtora possui uma pilha de cartões ou uma lista de emails de pessoas que foram abordadas em lançamentos, feiras e eventos. O que muitas empresas observam como simples dados, para o Inbound Marketing são informações extremamente valiosas. Serão esses contatos o nossos primeiros Leads a serem trabalhados e qualificados.

Importante: Se a sua imobiliária nunca fez nenhum tipo de comunicação via email, ou se faz muito tempo que você não troca mensagens com essas pessoas, vale a pena fazer a higienização da lista primeiro, ou seja, separar os contatos que podem ser usados dos que estão inválidos. Fazer essa prática economiza tempo na prospecção e aumenta as chances de conversão em vendas futuras.

Para esses contatos, devemos iniciar a comunicação com um template de email simples. Nosso objetivo é qualificar esses Leads, uma vez que eles já tiveram um primeiro contato com a sua imobiliária. Aqui valem desde estratégias básicas, como apresentar os novos empreendimentos, até mesmo algo agressivo para venda, como fazer ofertas.

Vale ressaltar que, em paralelo, esses Leads podem receber newsletters quinzenais sobre as novidades da sua imobiliária. Essa é uma ótima forma de ser lembrado, só precisamos tomar cuidado aqui para não enviar aos clientes que já realizaram uma compra a mesma oferta novamente.

Para ver como funciona, confira nosso case: Como a Cupola vendeu um apartamento por Email Marketing.

2- Geração de Leads

Ao mesmo tempo que os Leads já existentes estão sendo qualificados, é importante que novos Leads sejam gerados. Para isso, temos 2 opções principais:

Oferta fundo de funil (perto da venda)

As ofertas diretas contribuem para geração de Leads mais qualificados, que necessitam de menos tempo de nutrição, agilizando o processo de compra. No caso de imobiliárias, algumas práticas rápidas e simples podem cumprir essa função. Separamos algumas ideias para você colocar no ar já:

    • Landing Page com contagem regressiva para lançamento de novo empreendimento;
    • Ofertas com desconto ou com benefícios como “ganhe cozinha mobiliada” ou “ 2 garagens inclusas se fechar a compra neste mês”;
    • Agendamento de visita ao apartamento decorado;
    • Avaliação do seu imóvel para troca;
    • Vídeo de apresentação do imóvel com demonstração da planta baixa.

Ofertas topo de funil (primeiros passos do Lead)

Com a oferta de fundo de funil rodando, ganhamos tempo para preparar as personas e a jornada de compra, assim como os conteúdos para topo e meio de funil, que já podem servir para nutrição de Leads posteriormente. Aqui, conteúdos educativos que destacam diferenciais dos seus empreendimentos são muito bem-vindos:

    • Manual do inquilino;
    • Comparação entre bairros;
    • Dicas de como melhorar seu apartamento para venda;
    • Importância de ter um prédio com vigilância 24h;
    • Benefícios de morar perto do trabalho;
    • Vantagens de ter academia no prédio.

3 – Segmentação de Leads

Para essas Landing Pages que citamos na dica anterior, vale lembrar que incluir estratégias para segmentação de Leads desde o início facilita o trabalho de nutrição. Por exemplo, para o material de comparação entre bairros, já podemos pedir ao Lead qual a preferência dele e pensar em um fluxo de nutrição específico para aquele bairro. Dessa forma, você envia o conteúdo adequado para a persona ideal, otimizando o processo de decisão de compra.

Já para o “Manual do Inquilino” você pode questionar ao Lead qual o objetivo dele para saber se ele tem interesse em comprar, vender ou alugar. Caso o Lead selecione “alugar” e sua imobiliária não trabalhe com aluguéis, por exemplo, esse Lead não tem potencial para se tornar um cliente, ou seja, ele não precisa participar de um fluxo de nutrição de imediato.

Algumas outras opções de campo também contribuem para a segmentação de Leads, como:

  • Quantos quartos você precisa no apartamento? (Resposta: 2/ 2 a 3/mais de 3)
  • Você possui animais de estimação? (Resposta: sim/não)
  • Você possui filhos? (Resposta: sim/não)

Lembre-se apenas de que todas as informações perguntadas em formulários de Landing Pages devem ter um objetivo futuro. Perguntar apenas para saber, além de não ter finalidade, pode diminuir a conversão de visitantes para Leads.

4 – Parcerias com negócios locais

Se a sua imobiliária está explorando uma região desconhecida ou menos populosa, faz sentido que você procure negócios locais para fazer parcerias. Uma boa ideia é fechar parcerias com restaurantes que ficam nas redondezas para divulgar o novo empreendimento.

Por exemplo, sua imobiliária pode promover concursos culturais do tipo “Por que você moraria no bairro X”, estimulando os clientes a participarem em troca de um jantar grátis naquele mesmo restaurante. Além de você contribuir para o movimento do local, você também capta Leads através de uma Landing Page simples. Lembre-se de colocar um campo “você aceita receber emails sobre o empreendimento X” para garantir uma boa taxa de abertura e clique nas suas campanhas futuras.

O mesmo fluxo funciona para outros tipos de comércio, como salão de beleza, escolas e supermercados.

Resultado

A geração de Leads para topo e fundo de funil, com ações de qualificação de Leads em paralelo, são os primeiros passos para uma estratégia efetiva de Inbound Marketing imobiliário. Com ajustes rápidos e práticos, conseguimos ter pequenos benefícios como a redução no tempo do processo de venda.

Os números de mercado indicam que hoje a decisão de compra leva de 9 a 12 meses. Por isso, quanto antes você iniciar o planejamento a execução de estratégias, mais cedo sua imobiliária vai sentir o impacto dos resultados.

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.