Ultimamente, tenho passado muito tempo trabalhando com ferramentas de Big Data, em especial com o Apache Spark. Caso você não esteja familiarizado, o Apache
O Spark é uma ferramenta incrivelmente eficiente para processar grandes quantidades de dados. Seu desempenho é significativamente melhor do que o do MapReduce, e em
Na realidade, ele não é muito difícil de usar.
O Apache Spark funciona muito bem em combinação com o Couchbase por meio do Couchbase Spark Connector. Veremos o que é necessário para
carregar alguns dados brutos de valores separados por vírgula (CSV) no Couchbase usando o Apache Spark.
Os requisitos
Não há muitos requisitos para colocar esse projeto em funcionamento. No mínimo, você precisará do seguinte:
- Apache Spark 1.6.1
- JDK 1.8+
- Apache Maven 3.3+
- Servidor Couchbase 4.1+
A maior parte do desenvolvimento ocorrerá com o JDK 1.8 e o Maven, mas quando chegar a hora de executar o aplicativo, o Apache Spark
seja necessário, seja por meio de uma instância local ou remota.
Entendendo o conjunto de dados e o modelo de dados
Uma ótima maneira de se familiarizar com o Apache Spark é obter um conjunto de dados de amostra no site de ciência de dados,
Kaggle. Para este exemplo, vamos dar uma olhada no conjunto de dados de amostra chamado
Salários de SF que contém informações sobre a quantidade de dinheiro que o governo
os funcionários de São Francisco estão ganhando.
Do ponto de vista dos dados, há um único arquivo de valor separado por vírgula (CSV) chamado salários.csv com o seguinte
colunas nele:
- Id
- Nome do funcionário
- Cargo
- BasePay
- Pagamento de horas extras
- Outros pagamentos
- Benefícios
- TotalPay
- TotalPayBenefits
- Ano
- Notas
- Agência
- Status
Trabalhar com os dados no formato CSV é quase impossível. Ainda mais quando se trata de grandes quantidades de dados. Em vez disso, esses dados serão
armazenados como dados NoSQL para que possam ser processados posteriormente. Não entraremos em detalhes sobre o processamento de números e consultas aqui, mas isso virá em um
artigo futuro. No momento, queremos apenas colocá-lo no formato NoSQL.
Quando carregado no Couchbase, cada linha do CSV terá uma aparência semelhante à seguinte:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
{ "Id": "10029", "EmployeeName": "FERGAL CLANCY", "JobTitle" (Cargo): "INSPETOR DE CONSTRUÇÃO", "BasePay": "94529.22", "OvertimePay" (Pagamento de horas extras): "0", "OtherPay": "2502.6", "Benefícios": "", "TotalPay": "97031.82", "TotalPayBenefits": "97031.82", "Ano": "2011", "Notas": "", "Agência": "São Francisco", "Status": "" } |
Sim, o bloco de dados acima é um documento JSON, que é o que o Couchbase suporta. Agora que conhecemos os objetivos dos dados, podemos começar
carregar os dados CSV no Couchbase com o Apache Spark.
Transformando os dados brutos e gravando no Couchbase
Para usar o Apache Spark em um aplicativo Java, algumas dependências devem ser incluídas. Precisamos incluir o Spark Core, o Spark SQL, o Spark CSV e o
Conector do Couchbase Spark. Como estamos usando o Maven, tudo pode ser incluído por meio do Maven pom.xml arquivo. Para incluir
Spark Core, inclua a seguinte dependência em seu arquivo Maven:
|
1 2 3 4 5 6 7 |
org.apache.faísca faísca-núcleo_2.10 1.6.1 |
Como os dados brutos estarão na forma de CSV, podemos usar o pacote de conveniência do Spark chamado Spark CSV. A dependência do Maven
para o Spark CSV pode ser adicionado desta forma:
|
1 2 3 4 5 6 7 |
com.Tecidos de dados faísca-csv_2.10 1.4.0 |
Os dados CSV serão carregados em um Apache Spark DataFrame. Se você não estiver familiarizado com DataFrames, eles podem ser consultados usando o Spark
SQL. Isso faz parte de como colocaremos os dados no Couchbase. Para incluir o Spark SQL em seu projeto, adicione a dependência Maven
assim:
|
1 2 3 4 5 6 7 8 |
org.apache.faísca faísca-sql_2.10 1.6.1 fornecido |
Por fim, o Apache Spark precisa ser conectado ao Couchbase Server. Isso pode ser feito por meio do Couchbase Connector for Spark. Para
adicione essa dependência em seu projeto Maven, adicione o seguinte ao seu pom.xml file:
|
1 2 3 4 5 6 7 |
com.couchbase.cliente faísca-conector_2.10 1.1.0 |
Todas as dependências do projeto estão prontas para funcionar!
Para começar a carregar dados CSV por meio de código Java, o Apache Spark deve primeiro ser configurado em nosso projeto. Isso inclui definir o que o Spark
a ser usada e em qual bucket do Couchbase os dados serão armazenados.
|
1 2 3 4 5 6 7 |
SparkConf conf = novo SparkConf() .setAppName("Salários de SF") .setMaster("local[*]") .definir("com.couchbase.bucket.default", ""); JavaSparkContext javaSparkContext = novo JavaSparkContext(conf); |
O nome do aplicativo será Salários de SF e o cluster mestre do Spark será a máquina local
já que o Spark será executado localmente neste exemplo. O bucket do Couchbase a ser usado é, mais uma vez, o bucket padrão.
Para criar um Spark DataFrame, um SQLContexto deve ser criado a partir do JavaSparkContext.
|
1 2 3 |
SQLContexto sqlContext = novo SQLContexto(javaSparkContext); |
Usando o SQLContexto os dados CSV podem ser lidos dessa forma:
|
1 2 3 4 5 6 7 |
DataFrame dataFrame = sqlContext.ler() .formato("com.databricks.spark.csv") .opção("inferSchema", "true" (verdadeiro)) .opção("cabeçalho", "true" (verdadeiro)) .carregar("PATH_TO_CSV_FILE"); |
O processo de leitura usará o pacote Spark CSV e preservará as informações de cabeçalho que existem na parte superior do arquivo CSV.
Quando lidos em um DataFrame, os dados CSV agora são algo que o Couchbase pode entender.
Deve ser feito um ajuste nos dados de id. O Spark o reconhecerá como um número inteiro ou numérico porque esse conjunto de dados tem apenas
valores numéricos como a coluna. O Couchbase espera uma string id.
|
1 2 3 |
dataFrame = dataFrame.comColuna("Id", df.col("Id").elenco("string")); |
O DataFrame agora pode ser preparado para ser salvo no Couchbase.
|
1 2 3 |
Funções do DataFrameWriter DataFrameWriterFunctions = novo Funções do DataFrameWriter(dataFrame.escrever()); Mapa |
Com os dados do DataFrame canalizados para o Funções do DataFrameWriter o valor de id pode ser mapeado para um objeto
id do documento. Os dados nesse ponto podem ser salvos.
|
1 2 3 |
DataFrameWriterFunctions.couchbase(opções); |
Grandes quantidades de documentos do Couchbase serão salvas no bucket.
Executando o projeto com o Apache Spark
Empacote o projeto em um JAR executável usando o Maven. O projeto pode ser executado após ser empacotado, fazendo o seguinte
assim:
|
1 2 3 |
/caminho/para/apache/faísca/caixa/faísca-enviar --classe "com.app.Main" alvo/projeto-frasco-com-dependências.frasco |
Dependendo do tamanho do conjunto de dados e da velocidade de seu computador ou servidor, o processo de carregamento pode demorar um pouco.
Conclusão
Você acabou de experimentar o carregamento de dados CSV sujos no Couchbase usando o Apache Spark e o Couchbase Spark Connector. O Spark foi
projetado para poder processar rapidamente grandes quantidades de dados em tempo real. Combine-o com o Couchbase e seu sistema centrado na memória
e você tem um ótimo pacote de software.
