O Hadoop é ideal para processar grandes quantidades de dados e resolver essas informações em um conjunto pequeno de informações que você possa consultar. No entanto, o tempo de processamento desse processo pode ser enorme. Pela integração com o Couchbase Server, é possível fazer consulta em tempo real e gerar relatórios sobre informações, enquanto continua a trabalhar com o Hadoop para o conjunto de dados grande e o processamento pesado do conjunto de dados. O sistema de consulta Couchbase também usa um sistema de consulta MapReduce, que torna mais fácil para você migrar e integrar seu sistema de indexação e consulta para extrair e manipular as informações eficazmente.

Martin Brown, VP of Technical Publications, Couchbase

author photoEscritor profissional por mais de 15 anos, Martin 'MC' Brown é autor e colaborador de mais 26 livros que abordam uma série de tópicos, incluindo o recentemente publicado Getting Started with CouchDB. Sua especialidade abrange miríades de linguagens de desenvolvimento e plataformas Perl, Python, Java, JavaScript, Basic, Pascal, Modula-2, C, C++, Rebol, Gawk, Shellscript, Windows, Solaris, Linux, BeOS, Microsoft® WP, Mac OS e mais. Ele foi o Editor de Tecnologias LAMP da revista LinuxWorld e é um colaborador regular da ServerWatch.com, LinuxPlanet, ComputerWorld e IBM developerWorks. Ele conta com uma experiência rica e variada como membro fundador de um ISP líder no Reino Unido, gerente de sistemas e consultor de TI de uma agência de publicidade e grupo de soluções de Internet, especialista técnico de uma rede de ISP intercontinental e designer e programador de banco de dados. Além disso, ele ainda é um confesso consumidor compulsivo de hardware e software de computação. MC é atualmente o VP da Technical Publications and Education for Couchbase e é responsável por toda documentação publicada, programa de treinamento e conteúdo, e pela Couchbase Techzone.



01/Out/2012

Hadoop e processamento de dados

O Hadoop combina conjuntamente um número de recursos-chave os quais, por fim, tornam-se muito úteis para processamento de uma grande quantidade de dados em chunks menores, utilizáveis.

O componente primário é o sistema de arquivos HDFS, que leva em consideração as informações para serem distribuídas através de um cluster. As informações armazenadas nesse formato distribuído também podem ser processadas individualmente em cada nó de cluster por meio de um sistema denominado MapReduce. O processo MapReduce converte as informações armazenadas no sistema de arquivos HDFS em chunks menores, processados e mais gerenciáveis.

Como o Hadoop trabalha em vários nós, ele pode ser usado para processar uma vasta quantidade de informações de entrada e simplificá-la em blocos mais utilizáveis de informações. Esse processamento é manipulado usando um sistema MapReduce simples.

O MapReduce é uma forma de modelar as informações de entrada, que pode ou não estar em um formato estruturado, e convertê-las para uma estrutura que possa ser mais facilmente usada, consultada e processada.

Por exemplo, um uso típico é processar as informações de log de centenas de aplicativos diferentes de modo que seja possível identificar problemas, contagens e outros eventos específicos. Usando o formato do MapReduce, é possível iniciar a medir e procurar tendências — convertendo o que seria uma quantidade muito significativa de informações em um tamanho menor. Ao examinar os logs de um servidor da web, por exemplo, talvez você queira examinar os erros que ocorrem dentro de determinado intervalo em páginas específicas. É possível escrever uma função do MapReduce para identificar erros específicos nas páginas individuais, e gerar essas informações na saída. Usando esse método, é possível reduzir as muitas linhas de informações dos arquivos de log em uma coleção muito menor de registros contendo somente as infomações do erro.

Compreendendo o MapReduce

O MapReduce trabalha em duas fases. O processo de mapeamento toma as informações de entrada e as mapeia em um formato padronizado. Para alguns tipos de informações, esse mapeamento pode ser direto e explícito. Por exemplo, se estiver processando dados de entrada como um log da web, você estará extraindo uma única coluna de dados do texto do log da web. Para outros dados, o mapeamento pode ser mais complexo. Processando as informações textuais, por exemplo, documentos de pesquisa, é possível extrair frases ou blocos mais complexos de dados.

A fase de redução é usada para intercalar e resumir os dados conjuntamente. A redução pode ocorrer realmente em um número de diferentes modos, mas o processo típico é executar uma contagem básica, soma ou outras estatísticas com base nos dados individuais da fase de mapeamento.

Pensando sobre um exemplo simples, por exemplo, a contagem de palavras usadas como MapReduce de amostra no Hadoop, a fase de mapeamento separa texto bruto para identificar palavras individuais, e para cada palavra, gerar um bloco de dados de saída. A função de redução toma esses blocos de informações mapeados e os reduz para incrementar a contagem de cada palavra exclusiva vista. Dado um arquivo de texto único de 100 palavras, o processo de mapeamento gera 100 blocos de dados, mas a fase de redução resumirá isso para menos até chegar a uma contagem de cada palavra única em, digamos, 56 palavras, com uma contagem do número de vezes que cada palavra apareceu.

Com os logs da web, o mapa tomará os dados de entrada, criará um registro para cada erro dentro do arquivo de log e gerará um bloco para cada erro que contém a data, hora e página que causou o problema.

Dentro do Hadoop, a fase de MapReduce ocorrerá nos nós individuais em que os blocos individuais das informações de origem são armazenados. Isso é o que permite que o Hadoop trabalhe com conjuntos de dados de informações grandes — permitindo que vários nós trabalhem nos dados simultaneamente. Com 100 nós, por exemplo, é possível processar 100 arquivos de log simultaneamente e simplificar muitos gigabytes (ou terabytes) de informações muito mais rapidamente do que obteria por um único nó.

Limitações do Hadoops

Uma das principais limitações do produto Hadoop principal é que não há nenhum modo de armazenar e consultar informações no banco de dados. Os dados são incluídos no sistema HDFS, mas não é possível pedir para o Hadoop para retornar uma lista de todos os dados que correspondem a um conjunto de dados específico. O motivo primário para isso é que o Hadoop não armazena, estrutura ou compreende a estrutura de dados que está sendo armazenada dentro do HDFS. Isso é o porquê o sistema MapReduce é necessário para analisar e processar as informações em um formato mais estruturado.

No entanto, nós podemos combinar a energia de processamento do Hadoop com um banco de dados mais tradicional de modo que seja possível consultar os dados que o Hadoop gerou por meio do seu próprio sistema MapReduce. Há muitas soluções possíveis disponíveis, incluindo muitos bancos de dados SQL tradicionais, mas podemos manter o tema do MapReduce, que é muito efetivo para conjuntos de dados grandes usando o Couchbase Server.

A estrutura básica do compartilhamento de dados entre os sistemas é mostrada na Figura 1.

Figura 1. Estrutura básica do compartilhamento de dados entre os sistemas
Estrutura básica do compartilhamento de dados entre os sistemas

Instalando o Hadoop

Se você não instalou o Hadoop ainda, o modo mais fácil é fazer uso de uma das instalações do Cloudera. Para a compatibilidade entre o Hadoop, o Sqoop e o Couchbase, a melhor solução é fazer uso da instalação do CDH3 (veja Recursos). Para tal, será necessário usar o Ubuntu 10.10 a 11.10. Mais tarde, os releases do Ubuntu apresentaram uma incompatibilidade porque eles não suportam mais um pacote necessário para instalação do Cloudera Hadoop.

Antes da instalação, não se esqueça de ter instalado uma Java™ virtual machine, e assegurar de ter configurado o diretório inicial correto do seu JDK na variável JAVA_HOME. Observe que você tenha um Java Development Kit completo disponível, não apenas um Java Runtime Environment (JRE), à medida que o Sqoop compila o código para exportar e importar dados entre o Couchbase Server e o Hadoop.

Para instalar usando o CDH3 no Ubuntu e sistemas similares, é necessário fazer o que segue:

  1. Faça o download do pacote de configuração do CDH3. Isso inclui a configuração dos arquivos de origem CDH3 para o repositório competente.
  2. Atualize o cache do seu repositório: $ apt-get update.
  3. Instale o pacote principal do Hadoop: $ apt-get install hadoop-0.20.
  4. Instale os componentes do Hadoop (veja Listagem 1).
    Lista 1. Instalando os Componentes do Hadoop
    $ for comp in namenode datanode secondarynamenode jobtracker tasktracker
    do
    apt-get install hadoop-0.20-$comp
    done
  5. Edite os arquivos de configuração para assegurar que você configurou os componentes principais.
  6. Edite o /etc/hadoop/conf/core-site.xml para ler como mostrado na Listagem 2.
    Lista 2. Arquivo /etc/hadoop/conf/core-site.xml editado
    <configuration>
      <property>
        <name>fs.default.name</name>
        <value>hdfs://localhost:9000</value>
      </property>
    </configuration>

    Isso configura o local hdfs padrão para armazenar dados.
    Edite /etc/hadoop/conf/hdfs-site.xml (consulte a Listagem 3).
    Lista 3. Arquivo /etc/hadoop/conf/hdfs-site.xml editado
    <configuration>
      <property>
        <name>dfs.replication</name>
        <value>1</value>
      </property>
    </configuration>

    Isso permite a replicação dos dados armazenados.
    Edite /etc/hadoop/conf/mapred-site.xml (veja Listagem 4).
    Lista 4. Arquivo /etc/hadoop/conf/mapred-site.xml editado
    <configuration>
      <property>
        <name>mapred.job.tracker</name>
        <value>localhost:9001</value>
      </property>
    </configuration>

    Isso permite o rastreador de tarefa para o MapReduce.
  7. Finalmente, edite o ambiente do Hadoop para apontar para o seu diretório de instalação do JDK dentro de /usr/lib/hadoop/conf/hadoop-env.sh. Haverá uma linha comentada para a variável JAVA_HOME. Você deve remover o comentário da linha e configurá-la para o seu local do JDK. Por exemplo, export JAVA_HOME=/usr/lib/jvm/java-1.6.0-openjdk.
  8. Agora, inicie o Hadoop no seu sistema. O modo mais fácil é usar o script start-all.sh: $ /usr/lib/hadoop/bin/start-all.sh.

Presumindo que tudo esteja configurado corretamente, você deve ter agora um sistema Hadoop em execução.


Visão geral do Couchbase Server

O Couchbase Server é um sistema de banco de dados baseado em documento, disposto em cluster, que faz uso de uma camada de cache para fornecer acesso muito rápido aos seus dados armazenando a maioridade dos dados no RAM. O sistema faz uso de vários nós e uma camada de cache com sharding automático entre o cluster. Isso permite uma natureza elástica de modo que seja possível aumentar e reduzir o cluster para aproveitar mais RAM ou da E/S do disco e ajudar a melhorar o desempenho.

Todos os dados no Couchbase Server são eventualmente persistidos para o disco, mas inicialmente as escritas e atualizações operam por meio da camada de cache, que é o que fornece o alto desempenho e o que podemos explorar ao processar os dados do Hadoop para obter informações em tempo real e consultar os conteúdos.

Nessa forma básica, o Couchbase Server permanece como um documento básico e armazenamento chave/valor. É possível apenas recuperar as informações do cluster desde que você saiba o ID do documento. No Couchbase Server 2.0, você pode armazenar documentos no formato JSON e, em seguida, usar o sistema de visualização para criar uma view nos documentos JSON armazenados. Uma visualização é uma combinação de MapReduce que é executada pelos documentos armazenados no banco de dados. A saída de uma visualização é um índice, correspondendo à estrutura que você definiu pelas funções do MapReduce. A existência do índice fornece a você a capacidade de consultar os dados do documento subjacente.

É possível usar essa funcionalidade para tomar os dados processados do Hadoop, armazenar essas informações dentro do Couchbase Server e usá-las como nossa base para consultar esses dados. Convenientemente, o Couchbase Server usa um sistema MapReduce para processar os documentos e criar os índices. Isso fornece algum nível de compatibilidade e consistência com os métodos de processamento de dados.

Instalando o Couchbase Server

Instalar o Couchbase Server é fácil. Faça o download do release do Couchbase Server 2.0 do website do Couchbase para a sua plataforma (veja Recursos), e instale o pacote usando o dpkg ou RPM (dependendo da sua plataforma).

Depois da instalação, o Couchbase Server iniciará automaticamente. Para configurá-lo, abra um navegador da web e aponte para localhost:8091 na sua máquina (ou acesse-o remotamente usando o endereço IP da máquina).

Siga as instruções de configuração na tela. É possível usar a maioria das configurações padrão como fornecidas durante a instalação, mas as configurações mais importantes são o local dos arquivos de dados para os dados escritos no banco de dados, e a quantidade de RAM que você aloca para o Couchbase Server.


Usando o Couchbase Server para conversar com o conector do Hadoop

O Couchbase Server usa o conector Sqoop para se comunicar com o cluster do Hadoop. O Sqoop fornece uma conexão para transferir dados em massa entre o Hadoop e o Couchbase Server.

Tecnicamente, o Sqoop é um aplicativo projetado para converter informações entre bancos de dados estruturados e o Hadoop. O nome Sqoop é realmente derivado de SQL e Hadoop.

Instalando o Sqoop

Se você estiver usando a instalação do CDH3, poderá instalar o sqoop usando seu gerente de pacotes: $ sudo apt-get install sqoop.

Isso instalará o sqoop em /usr/lib/sqoop.

Nota: Um erro recente no Sqoop significa que ele tentará algumas vezes transferir os conjuntos de dados errados. A correção é parte do Sqoop Versão 1.4.2. Se você experimentar problemas, tente a V1.4.2 ou uma versão posterior.

Instalando o Connector Couchbase Hadoop

O Connector Couchbase Hadoop é uma coleção de arquivos jar Java que suporta a conectividade entre o Sqoop e o Couchbase. Faça o download do conector Hadoop do website do Couchbase (veja Recursos). O arquivo é empacotado como um arquivo zip. Descompacte-o e execute o script install.sh dentro dele, fornecendo a localização do sistema Sqoop. Por exemplo, $ sudo bash install.sh /usr/lib/sqoop.

Esse instala todos os arquivos de biblioteca e configuração necessários. Agora que podemos iniciar a troca de informações entre os dois sistemas.

Importando Dados do Couchbase Server para o Hadoop

Apesar de não ser o cenário com que lidaremos diretamente aqui, é digno de nota que podemos exportar dados do Couchbase Server para o Hadoop. Isso pode ser útil se você tiver carregado uma grande quantidade de dados no Couchbase Server, e quiser aproveitar o Hadoop para processá-lo e simplificá-lo. Para fazer isso, é possível carregar o conjunto de dados inteiro do Couchbase Server para um arquivo Hadoop dentro do HDFS usando: $ sqoop import --connect http://192.168.0.71:8091/pools --table cbdata.

A URL fornecida aqui é o local do conjunto de depósitos do Couchbase Server. A tabela especificada aqui é realmente o nome do diretório dentro do HDFS onde os dados serão armazenados.

Os dados em si são armazenados como um dump de chave/valor de informações do Couchbase Server. No Couchbase Server 2.0, isso significa que os dados são gravados usando o ID de documento único, e contendo o valor JSON do registro.

Gravando os dados do JSON no Hadoop MapReduce

Para trocar informações entre o Hadoop e o Couchbase Server, precisamos falar uma linguagem comum, nesse caso, a JSON (veja Listagem 5).

Lista 5. Saída da JSON dentro do Hadoop MapReduce
package org.mcslp;

import java.io.IOException;
import java.util.*;

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.conf.*;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapred.*;
import org.apache.hadoop.util.*;
import com.google.gson.*;

public class WordCount {

    public static class Map extends MapReduceBase implements Mapper<LongWritable,
Text, Text, IntWritable> {
        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();

        public void map(LongWritable key, Text value, OutputCollector<Text,
IntWritable> output, Reporter reporter) throws IOException {
            String line = value.toString();
            StringTokenizer tokenizer = new StringTokenizer(line);
            while (tokenizer.hasMoreTokens()) {
                word.set(tokenizer.nextToken());
                output.collect(word, one);
            }
        }
    }

    public static class Reduce extends MapReduceBase implements Reducer<Text,
IntWritable, Text, Text> {

        class wordRecord {
            private String word;
            private int count;
            wordRecord() {
            }
        }

        public void reduce(Text key,
                           Iterator<IntWritable> values,
                           OutputCollector<Text, Text> output,
                           Reporter reporter) throws IOException {
            int sum = 0;
            while (values.hasNext()) {
                sum += values.next().get();
            }

            wordRecord word = new wordRecord();
            word.word = key.toString();;
            word.count = sum;

            Gson json = new Gson();
            System.out.println(json.toJson(word));
            output.collect(key, new Text(json.toJson(word)));
        }
    }

    public static void main(String[] args) throws Exception {
        JobConf conf = new JobConf(WordCount.class);
        conf.setJobName("wordcount");

        conf.setOutputKeyClass(Text.class);
        conf.setOutputValueClass(IntWritable.class);

        conf.setMapperClass(Map.class);
        conf.setReducerClass(Reduce.class);

        conf.setInputFormat(TextInputFormat.class);
        conf.setOutputFormat(TextOutputFormat.class);

        FileInputFormat.setInputPaths(conf, new Path(args[0]));
        FileOutputFormat.setOutputPath(conf, new Path(args[1]));

        JobClient.runJob(conf);
    }
}

O código é uma modificação da amostra de contagem fornecido com a distribuição do Hadoop.

Essa versão usa a biblioteca do Google Gson para gravar as informações da JSON na fase de redução do processamento. Para conveniência, uma nova classe é usada (wordRecord), que é convertida pelo Gson em um registro JSON, que é o formato de que necessitamos em um documento da base de documentos do Couchbase Server para processar e analisar os conteúdos.

Observe que não definimos uma classe Combiner para o Hadoop. Isso evitará que o Hadoop tente reduzir novamente as informações, o que com o código atual falhará porque nossa redução captura a palavra e um único dígito e gera uma saída para um valor JSON. Para um estágio de redução/combinação secundária, precisaremos analisar a entrada da JSON ou definir uma nova classe Combiner que faça a saída da versão de JSON das informações. Isso simplifica um pouco a definição.

Para usar isso dentro do Hadoop, primeiro é necessário copiar a biblioteca Google Gson no diretório do Hadoop (/usr/lib/hadoop/lib). Em seguida, reinicie a biblioteca que foi corretamente identificada pelo Hadoop.

Depois, compile o seu código em um diretório: $ javac -classpath ${HADOOP_HOME}/hadoop-${HADOOP_VERSION}-core.jar:./google-gson-2.2.1/gson-2.2.1.jar -d wordcount_classes WordCount.java .

Agora crie um jar da sua biblioteca: $ jar -cvf wordcount.jar -C wordcount_classes/.

Com isso concluído, é possível copiar um número de arquivos de texto em um diretório e usar esse jar para processar os arquivos de texto em uma conta de palavras individuais, com um registro JSON contendo a palavra, e a conta. Por exemplo, para processar esses dados em alguns textos do Projeto Gutenberg: $ hadoop jar wordcount.jar org.mcslp.WordCount /user/mc/gutenberg /user/mc/gutenberg-output.

Isso gerará uma lista de palavras no diretório de saída sendo contadas pela função MapReduce dentro do Hadoop.

Exportando os Dados do Hadoop para o Couchbase Server

Para obter os dados de volta do Hadoop para o Couchbase Server, precisamos usar o Sqoop para exportar os dados novamente: $ sqoop export --connect http://10.2.1.55:8091/pools --table ignored --export-dir gutenberg-output.

O argumento --table neste exemplo é ignorado, mas o --export-dir é o nome do diretório onde as informações a serem exportadas estão localizadas.


Gravando o MapReduce no Couchbase Server

Dentro do Hadoop, as funções do MapReduce são gravadas usando o Java. Dentro do Couchbase Server, a funcionalidade do MapReduce é gravada no Javascript. Como uma linguagem interpretada, isso significa que você não precisa compilar a visualização e permite que você edite e refine a estrutura do MapReduce.

Para criar uma visualização dentro do Couchbase Server, abra o console de administração (em http://localhost:8091), e clique em View As visualizações são coletadas dentro de um documento de design. É possível criar várias visualizações em um único documento de design e crie vários documentos de design. Para melhorar o desempenho geral do servidor, o sistema também suporta uma visualização de desenvolvimento que pode ser editada, e uma visualização de produção que não pode ser editada. A visualização de produção não pode ser editada porque fazer isso invalidará o índice de visualização e fará com que o índice necessite de reconstrução.

Clique no botão Create Development View e atribua um nome ao seu documento de design e visualização.

Dentro do Couchbase Server, há as mesmas duas funções: mapear e reduzir. A funçaõ mapear é usada para mapear os dados de entrada (documentos JSON) a uma tabela. A funçaõ reduzir é usada para resumir e reduzir isso. As funções de redução são opcionais e não são necessárias para a funcionalidade do índice, assim ignoraremos as funções reduzir para os fins deste artigo.

Para a função mapear , o formato da função é mostrada na Listagem 6.

Lista 6. Formato da função mapear .
map(doc) {

}

O documento de argumentos é cada documento JSON armazenado. O formato de armazenamento do Couchbase Server é um documento JSON e a visualização está em Javascript, assim podemos acessar um campo na JSON denominado count usando: doc.count.

Para emitir as informações de nossa função mapear , chame a função emit(). A função emit() toma dois argumentos, o primeiro é a chave, que é usada para selecionar e consultar informações, e o segundo argumento é o valor correspondente. Assim podemos criar uma função mapear que gera a saída da palavra e a contagem usando o código na Listagem 7.

Lista 7. A função mapear que gera a saída da palavra e a contagem
function (doc) {
  if (doc.word) {
  	emit(doc.word,doc.count);
  }
}

Isso gerará uma saída da linha de dados para cada documento de entrada, contendo o ID do documento (na verdade, nossa palavra), a palavra como uma chave, e a contagem das incidências dessa palavra no texto de origem. É possível ver a saída JSON bruta na Listagem 8.

Lista 8. A saída JSON bruta
{"total_rows":113,"rows":[
{"id":"acceptance","key":"acceptance","value":2},
{"id":"accompagner","key":"accompagner","value":1},
{"id":"achieve","key":"achieve","value":1},
{"id":"adulteration","key":"adulteration","value":1},
{"id":"arsenic","key":"arsenic","value":2},
{"id":"attainder","key":"attainder","value":1},
{"id":"beerpull","key":"beerpull","value":2},
{"id":"beware","key":"beware","value":5},
{"id":"breeze","key":"breeze","value":2},
{"id":"brighteyed","key":"brighteyed","value":1}
]
}

Na saída, id é o ID do documento, key é a chave que você especificou na instrução emit, e value é o valor especificado na instrução emit.


Obtendo dados em tempo real

Agora que processamos as informações no Hadoop, importamos as informações para o Couchbase Server e criamos uma visualização nesses dados dentro do Couchbase Server, podemos iniciar a consulta das informações que processamos e armazenamos. As visualizações são acessadas usando um REST como API, ou se estiver usando um dos SDKs do Couchbase Server, por meio das funções de consulta de visualização correspondentes.

A consulta é possível por três seleções principais:

  • Chave individual. Por exemplo, mostrando as informações que correspondem a uma chave específica, por exemplo 'unkind'.
  • Lista de chaves. É possível fornecer uma array de valores de chave, e isso retornará todos os registros onde a chave da visualização corresponde a um dos valores fornecidos. Por exemplo, ['unkind','kind'] retornará os registros que correspondem a qualquer uma das palavras.
  • Intervalo de chaves . É possível especificar uma chave de início e uma chave de término.

Por exemplo, para localizar a contagem de uma palavra especificada, você usa o argumento chave para a visualização:

http://192.168.0.71:8092/words/_design/dev_words/_view/byword?connection_timeout=
            60000&limit=10&skip=0&key=%22breeze%22

O Couchbase Server naturalmente gera como saída os resultados de um MapReduce em um modo solicitado UTF-8, classificado pela chave especificada. Isso significa que é possível obter um intervalo de valores especificando o valor de início e o valor de término. Por exemplo, para obter todas as palavras entre 'breeze' e 'kind:

http://192.168.0.71:8092/words/_design/dev_words/_view/byword?connection_timeout=
            60000&limit=10&skip=0&startkey=%22breeze%22&endkey=%22kind%22

A consulta é simples, mas muito eficiente, especialmente quando percebe-se que é possível combiná-la com o sistema de visualização flexível para gerar dados no formato que deseja.


Conclusão

O Hadoop por conta própria fornece uma plataforma de processamento eficiente, mas não há nenhum método para extrair realmente informações úteis dos dados que estão processados. Por conectar o Hadoop a outro sistema, é possível usá-lo para consultar e extrair informações. Como o Hadoop usa o MapReduce para processamento, é possível aproveitar o conhecimento do MapReduce por meio do sistema MapReduce no Couchbase Server para fornecer sua plataforma de consulta. Usando esse método, você processa no Hadoop, exporta do Hadoop para o Couchbase Server como um documento JSON, e usa o MapReduce no Couchbase Server para consultar as informações processadas.

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre
ArticleID=838462
ArticleTitle=Usando o Hadoop com Couchbase
publish-date=10012012