java - multinodo - how to make cluster in hadoop

Usando Hadoop para encontrar archivos que contienen una cadena en particular

Question

Tengo alrededor de 1000 files y cada archivo es del tamaño de 1GB . Y necesito encontrar una Cadena en todos estos 1000 files y también qué archivos contienen esa Cadena en particular. Estoy trabajando con Hadoop File System y todos esos 1000 files están en Hadoop File System.

Todos los 1000 files están en una carpeta real, así que si me gusta más abajo, obtendré los 1000 files . Y necesito encontrar qué archivos contienen un String hello en particular en la carpeta real.

bash-3.00$ hadoop fs -ls /technology/dps/real

Y esta es mi estructura de datos en hdfs-

row format delimited 
fields terminated by ''/29''
collection items terminated by '',''
map keys terminated by '':''
stored as textfile

¿Cómo puedo escribir trabajos de MapReduce para resolver este problema en particular para poder encontrar qué archivos contienen una cadena en particular? Cualquier ejemplo simple me será de gran ayuda.

Actualizar:-

Con el uso de grep en Unix, puedo resolver el escenario de problema anterior, pero es muy lento y toma mucho tiempo obtener la salida real.

hadoop fs -ls /technology/dps/real | awk ''{print $8}'' | while read f; do hadoop fs -cat $f | grep cec7051a1380a47a4497a107fecb84c1 >/dev/null && echo $f; done

Esa es la razón por la que estaba buscando algunos trabajos de MapReduce para hacer este tipo de problema ...

Answer 1

Para obtener el nombre de archivo que está procesando actualmente, haga lo siguiente:

((FileSplit) context.getInputSplit()).getPath().getName() 

Cuando busque su registro de archivo por registro, cuando vea hello , emita la ruta anterior (y tal vez la línea o cualquier otra cosa).

Establezca el número de reductores en 0, no están haciendo nada aquí.

¿El ''formato de fila delimitado'' significa que las líneas están delimitadas por una nueva línea? en cuyo caso TextInputFormat y LineRecordReader funcionan bien aquí.

Answer 2

Parece que estás buscando un programa similar al grep, que es fácil de implementar usando Hadoop Streaming (la API Hadoop Java también funcionaría):

Primero, escriba un asignador que emite el nombre del archivo que se está procesando si la línea que se está procesando contiene su cadena de búsqueda. Usé Python, pero cualquier lenguaje funcionaría:

#!/usr/bin/env python
import os
import sys

SEARCH_STRING = os.environ["SEARCH_STRING"]

for line in sys.stdin:
    if SEARCH_STRING in line.split():
        print os.environ["map_input_file"]

Este código lee la cadena de búsqueda de la variable de entorno SEARCH_STRING . Aquí, dividí la línea de entrada y verifico si la cadena de búsqueda coincide con cualquiera de las divisiones; puede cambiar esto para realizar una búsqueda de subcadenas o usar expresiones regulares para buscar coincidencias.

A continuación, ejecute un trabajo de transmisión Hadoop utilizando este asignador y sin reductores:

$ bin/hadoop jar contrib/streaming/hadoop-streaming-*.jar /
    -D mapred.reduce.tasks=0
    -input hdfs:///data /
    -mapper search.py /
    -file search.py /
    -output /search_results /
    -cmdenv SEARCH_STRING="Apache"

La salida se escribirá en varias partes; para obtener una lista de coincidencias, simplemente puede cat los archivos (siempre que no sean demasiado grandes):

$ bin/hadoop fs -cat /search_results/part-*
hdfs://localhost/data/CHANGES.txt
hdfs://localhost/data/CHANGES.txt
hdfs://localhost/data/ivy.xml   
hdfs://localhost/data/README.txt
... 

Answer 3

Puedes intentar algo como esto, aunque no estoy seguro de si es una forma eficiente de hacerlo. Avíseme si funciona, no lo he probado ni nada.

Puede usarlo así: java SearchFiles / technology / dps / real hello asegurándose de ejecutarlo desde el directorio apropiado, por supuesto.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class SearchFiles {

    public static void main(String[] args) throws IOException {
        if (args.length < 2) {
            System.err.println("Usage: [search-dir] [search-string]");
            return;
        }
        File searchDir = new File(args[0]);
        String searchString = args[1];
        ArrayList<File> matches = checkFiles(searchDir.listFiles(), searchString, new ArrayList<File>());
        System.out.println("These files contain ''" + searchString + "'':");
        for (File file : matches) {
            System.out.println(file.getPath());
        }
    }

    private static ArrayList<File> checkFiles(File[] files, String search, ArrayList<File> acc) throws IOException {
        for (File file : files) {
            if (file.isDirectory()) {
                checkFiles(file.listFiles(), search, acc);
            } else {
                if (fileContainsString(file, search)) {
                    acc.add(file);
                }
            }
        }
        return acc;
    }

    private static boolean fileContainsString(File file, String search) throws IOException {
        BufferedReader in = new BufferedReader(new FileReader(file));
        String line;
        while ((line = in.readLine()) != null) {
            if (line.contains(search)) {
                in.close();
                return true;
            }
        }
        in.close();
        return false;
    }
}