prueba mapa

Procesamiento Masivo y Escalable de Datos (con MapReduce (Hadoop) ) CLASE 3

Distributed Filesystem overview

Los sistemas de archivos distribuidos permiten el acceso a archivos por equipos remotos como si estuvieran alojados localmente, esto hace que multiples usuarios en diferentes máquinas puedan compartir y almacenar archivos.

NFS & AFS

NFS(Network File System)

En 1985 "Sun Microsystems" creó el sistema de archivos NFS, presentado con estandar Unix FS interface, NFS es "stateless", no guarda estados de lo las peticiones que recibió por un usuario, razón por la cual es muy rápido, esta también podría ser una desventaja porque no se podria tener un historial de las peticiones que hizo determinado usuario en algún momento.
NFS Bloquea los archivos cuando estan siendo usados por otros usuarios, permitiendo así mantener la consistencia de los archivos.
NFS no es escalable por las razones mencionadas anteriormente

AFS (The Andrew Filesystem)

Fué desarrollado por la universidad de Carnegie Mellon como parte del Andrew Project , AFS fue desarrollado como una mejora NFS, entre las cosas que implementa: Utiliza autentificación Kerberos, implementa listas de control de acceso en los directorios para usuarios y grupos.

GFS (The google Filesystem)

Google necesitaba un sistema de archivos distribuido, decidieron crear uno propio, basado en sus necesidades, las asumciones que consideró google para desarrollar este sistema de archivos fueron entre otras; las fallas de hardware son la norma, no la execpcion, para uso de archivos enormes y pocos archivos pequeños, los archivos normalmente serán escritos una sola vez y al final del archivo.

En la siguiente figura se muestra como trabaja este sistema de archivos .
Existe un GFS master, GFS chunck servers, GFS clients. Los archivos son guardados en los GFS chunck servers en chuncks de 64 MB, el master administra copias de estos chuncks entre chunk servers, e información sobre la dirección de cada copia, metadatos, y el namespace de los archivsos, el cliente pide un archivo al master, este le reponde la ubicacion del archivo en el chunck server, y ahora el cliente se comunica directamente con el chunck server para transmitir los datos, de esta namera no se crea un cuello de botella en el master.

Aumentar el tamaño de un disco virtual en VMware

Tengo el siguiente esquema: SO windows, vmware 6.5 con ubuntu

Para cambiar el tamaño de un disco virtual en vmware se podrá usar la herramienta
vmware-vdiskmanager.exe, que se encuentra en la carpeta donde se instaló el vmware
ejm:

Abrir el cmd y moverse al directorio donde se encuentra instalado en vmware

c:\> cd C:\Program Files\VMware\VMware Workstation

Ejecutar el diskmanager (ejemplo queremos aumentar a 20 gb)

c:\Program Files\VMware\VMware Workstation> vmware-vdiskmanager.exe -x 20GB
"direccion donde se encuentra el disco virtual\nombredisco.vmdk"

Listo :D , si les da el siguiente error "The selected operation can only be executed on a disk with no snapshots." , Esta tarea se realiza con la opción "-r" de vmware-vdiskmanager que permite convertir un disco virtual hacia otro tipo.

Tipos de Disco:
0 : único archivo (expandible).
1 : divide el disco virtual en trozos de 2GB (expandible)
2 : espacio físico reservado
3 : similar al caso 1 pero con el espacio físico reservado.

c:\Program Files\VMware\VMware Workstation>vmware-vdiskmanager.exe -r
origen.vmdk -t 0 destino.vmdk

Ahora si pueden utilizar la opción -x

Ahora podemos iniciar la maquina virtual de ubuntu, si corremos el comando df -h , nos dira las particiones que tenemos y cuanto espacio tienen, si no aparecen la cantidad de gb que aumentamos tendremos que usar una herramienta que permita manipular las particiones
, una herramienta es gparted, si no la tenemos instalada entonces con permiso de root la instalamos

# sudo apt-get install gparted

luego de ello ya se puede usar la herramienta y al poner gparted en el terminal se abrira un modo grafico para poder editar las particiones, veremos el espacio que tenemos libre como unllocated, creamos una nueva particion con de tipo ext3, guardamos los cambios, adicionalmente hay que montar la particion, lo haremos manualmente para lo cual necesitamos una carpeta en el que montarlo

#mkdir /data

Esto creará una carpeta de nombre data dentro de / , y montamos la particion en esta carpeta

#mount /dev/sda3 /data

y Listo , ahora necesitamos que esta particion quede montada permanentemente, para lo cual necesitaremos editar un archivo llamado fstab ubicado en /etc

#cd /etc
#vi fstab

esto desplegará la info que está en este archivo y añadimos la siguiente linea al final

/dev/sda3 /data ext3 relatime,errors=remount-ro 0 1

y ahora si, cuando reiniciemos el ubuntu, la particion se montará al iniciar

Espero haya sido de utilidad...

Procesamiento Masivo y Escalable de Datos (con MapReduce (Hadoop) ) CLASE 2

La Programación funcional es un paradigma de programación declarativa basado en la utilización de funciones matemáticas.
Una característica propia de estos lenguajes son la no existencia de asignaciones de variables y la falta de construcciones estructuradas como la secuencia o la iteración (lo que obliga en la práctica a que todas las repeticiones de instrucciones se lleven a cabo por medio de funciones recursivas.
como ejemplo de lenguajes funcionales tenemos Lisp y Standard ML entre otros.

El verdadero origen de todo esto está en LISP, De ahí vienen sus nombres. MAP y REDUCE son funciones de orden superior. MAP básicamente lo que hace es tomar una lista y aplicarle una función a cada uno de los elementos y REDUCE le aplica una operación binaria para combinar los elementos.

El siguiente grafico, muestra como trabaja map reduceCon Map Reduce existe paralelización y distribución implicita, toleracia a fallos, tiene herramientas de monitoreo, y permite la abstracción a los programadores.

Procesamiento Masivo y Escalable de Datos (con MapReduce (Hadoop) ) CLASE 1

Entre los temas:

Introducción a la programación en paralelo
La computación en paralelo es el uso simultáneo de recursos del computador para resolver un problema, existen algunos modelos para hacer programación en paralelo, entre los más comunes; memoria compartida, hilos, paso de mensajes.

Parallel vs. Distributed
La diferencia entre paralelo y distribuido es una pieza importante a la hora de diseñar sistemas, los conceptos son significativamente diferentes, la confusión, si es que existiese es porque lo paralelo y lo distribuido tienen algo en común - la división de un problema en multiples tareas que pueden ser ejecutadas independientemente.

Cual es la diferencia, que es lo que hace a lo distribuido distribuido y a lo paralelo paralelo, los dos incluyen hacer multiples tareas en multiples CPUs separados, pero la diferencia clave es donde residen esos CPUs (tomando CPU y core como sinónimos)

Paralelo: las tareas son divididas entre CPUs dentro del mismo host.
Distribuido: las tareas son divididas entre CPUs en host separados.

Parallelization & Synchronization
La comunicación y la sincronización entre diferentes subtareas es uno de los grandes obstaculos en el rendimiento de los estos programas, pues la memoria no puede ser compartida por estas subtareas por ello existen los semáforos, barreras y otros metodos de sincronización muy conocidos.

Prelude to MapReduce
MapReduce es un framework introducido por Google para dar soporte a la computación paralela, la idea general es esconder toda la complejidad de hacer programas distribuidos, olvidandonos de así de los problemas de sincronización.

El modelo Google, un modelo innovador

Un modelo innovador, así es como cataloga Bernard Girard al modelo de negocio de Google en su libro titulado “The Google Model”, aunque la historia de Sergey Brin y Larry Page se parece a la de muchos de los empresarios como; Steve Jobs y Bill Gates, Herry Ford y Alfred Sloan, ellos decidieron llevar su empresa de una manera poco convencional.

Estoy leyendo el libro por segunda vez, la verdad es que me parece que es una buena inversión, para aquellos que desean crear una compañía,ayuda a tener idea de los modelos administrativos que pueden servir como referencia a la hora de emprender su propio negocio.

Les dejo el enlace de Bernard Girard hablando sobre su libro, en lo personal lo recomiendo.

Usando CORBA con el compilador de java

En 4 pasos describiré como usar corba.

PASO 1:

Lo primero que hay que hacer es crear el idl, la interface que deberá ser implementada

ClienteRemoto.idl

module ClienteRemoto{
              interface ClienteRem
             {
                   string Saludar(in string nombre);
     };
};

Esta idl será compilada para usar POA (Portable Object Adaptor) con el comando idlj de java :

>idlj -fall ClienteRemoto.idl

este comando creará una carpeta de nombre ClienteRemoto dentro de ella existirá el codigo necesario tanto en el servidor y en el cliente 

PASO 2:

Implementamos la interface que se creó usando el idl , crearemos un archivo llamado ClienteRemImp.java y haremos que extienda de la interface ClienteRemotoPOA que se encuentra en la carpeta  ClienteRemoto

ClienteRemImpl.java

public class ClienteRemImpl extends ClienteRemoto.ClienteRemPOA
{
                 public ClienteRemImpl(){}
                 public String Saludar(String nombre){
                        return "Hola "+nombre;
                  }
}

PASO 3 

Crear el Servidor que se quedará escuchando por peticiones

Servidor.java

import org.omg.CORBA.ORB;
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.POAHelper;
                         public class Servidor{
                             public static void main(String[] args){
                                      //inicializa orb 
                                        System.out.println("Iniciando");
                                       try {
                                               // crear e inicializar ORB
                                               ORB orb = ORB.init(args, null);
                                                // crear un objeto remoto
                                              ClienteRemImpl impl = new ClienteRemImpl();
                                               // obtener referencia rootpoa y activar el POAManager
                                               POA rootpoa = POAHelper.narrow(orb
                                                                                  .resolve_initial_references("RootPOA"));
                                              rootpoa.the_POAManager().activate();
                                             // obtener una referencia al objeto remoto
                                               org.omg.CORBA.Object ref = rootpoa.servant_to_reference(impl);
                                             ClienteRemoto.ClienteRem href =                                    ClienteRemoto.ClienteRemHelper.narrow(ref);
                                               // las siguientes lineas me permiten publicar un obj remoto
                                                org.omg.CORBA.Object objRef = orb
                                                                   .resolve_initial_references("NameService");
                                                NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
                                               // nombre con el cual voy a publicar mi objeto
                                                 String nombre = "ClienteRemoto";
                                                 NameComponent path[] = ncRef.to_name(nombre);
                                                // publicar el objeto
                                                 ncRef.rebind(path, href);
                                                // ejecutar el orb
                                                orb.run();
                                      } catch (Exception e) {
                                                   System.err.println("ERROR: " + e);
                                     }
       }
}

Paso 4

Crear el cliente, que usará los objetos remotos

Cliente.java 

import org.omg.CORBA.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
     public class Cliente {
        public static void main(String args[]) {
            try{
                ORB orb = ORB.init(args,null);
// obtener una referencia a NameService
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
// las siguientes lineas nos permiten obtener una ref a un objeto remoto
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
// nombre del obj remoto
String nombre = "ClienteRemoto";
   ClienteRemoto.ClienteRem impl =ClienteRemoto.ClienteRemHelper.narrow(ncRef.resolve_str(nombre));
System.out.println(impl.Saludar("Irene"));
}
catch (Exception e) {
System.out.println("ERROR : " + e);
e.printStackTrace(System.out);
}
}
}

 Ahora si, a compilar y usar, en la ventana de comando nos movemos al directorio donde hemos creado estos archivos y ejecutamos

 

> java *.java

luego en consolas  diferentes ejecutamos

>orbd -ORBInitialPort 2500

 

>java Servidor -ORBInitialPort 2500

 

>java Cliente -ORBInitialPort 2500

y hemos creado el hola mundo distribuido usando CORBA , espero sea útil.