Lexuz, un sistema distribuido

Un Sistema Distribuido es un sistema de computadoras en interconexión, que se comportan como una sola a pesar de estar compuestas por varios elementos. Al estar todas ellas en una red, el usuario puede consultar información sin importar si ésta se originó en otra computadora, ya que todas pueden tener acceso a la misma información y a los mismos procesos.

Este es el objetivo de los sistemas distribuidos, el establecer una comunicación Cliente-Servidor y el compartimiento de recursos de manera eficiente, segura y rápida. Todo esto se logra mediante el uso de mensajes entre las partes.

Lexuz es distribuido porque se compone de un servidor, en el cual se encuentra la base de datos y el programa ejecutándose, y de varios clientes, desde donde se puede accesar al sistema sin necesidad de tener la base de datos o el programa ejecutándose en la maquina cliente.

Esto se logra ya que se comunican utilizando la IP del servidor, se conectan a este y pueden obtener información generada por otra maquina cliente y ejecutar procesos.

Juego Distribuido

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ServidorTCP {
 private static final int INACTIVO = 0;
 private static final int JUGANDO = 1;
 private static final int GANO = 2;
 private static final int PERDIO = 3;
 private static final int SOLICITANDO_JUEGO_NUEVO = 4;
 private static final int nroPuerto = 8080;
 private static boolean SocketDisponible = true;
 private static int conexionesRealizadas = 0;
 private static Socket con;
 private static int estadoJuego = INACTIVO;
 private static char letra = '?';
 private static String palabra = "?";
 private static String palabraEnProgreso = "?";
 private static int nroIntentos = 6;
 static private final String[] palabrasAhorcado = {"reingenieria", "cubeta","tunelizacion", "protocolo", "puertos", "conexion", "broadcasting", "direccion","internet", "router", "switch", "wifi", "estandar", "socket", "transporte","enlace", "capas", "arquitectura", "cliente", "servidor", "proxy", "firewall","redes", "LAN", "WAN", "MAN", "hub", "concentrador", "datagrama", "puente","fibra", "TCP", "UDP", "mascara", "gateway", "servidor", "DNS", "cliente","conmutacion", "circuito", "satelite", "coaxial", "microondas", "señal","ingrarrojos", "token", "anillo", "bus", "control", "flujo", "congestion","enrutamiento", "aplicacion", "correo", "peertopeer", "reingenieria", "cubeta","tunelizacion", "protocolo", "puertos", "conexion", "broadcasting", "direccion","internet", "router", "switch", "wifi", "estandar", "socket", "transporte","enlace", "capas", "arquitectura", "cliente", "servidor", "proxy", "firewall","redes", "LAN", "WAN", "MAN", "hub", "concentrador", "datagrama", "puente","fibra", "TCP", "UDP", "mascara", "gateway", "servidor", "DNS", "cliente","conmutacion", "circuito", "satelite", "coaxial", "microondas", "señal","ingrarrojos", "token", "anillo", "bus", "control", "flujo", "congestion","enrutamiento", "aplicacion", "correo", "peertopeer"};
 private static int nroMensaje = 0;
 public static void main(String[] args) throws IOException {
     ServerSocket socketDeServicio = null;
  try {
      socketDeServicio = new ServerSocket(nroPuerto);
   BufferedReader entrada;
   DataOutputStream salida;
   while (true) {
      try {
          if (SocketDisponible) {
          //EL SOCKET ESTA DISPONIBLE, POR LO TANTO NO SE ESTA EN JUEGO
       if (estadoJuego == INACTIVO) {
           System.out.println("\nEsperando cliente...");
        con = socketDeServicio.accept();
        System.out.println("Conexion aceptada...\n");
        salida = new DataOutputStream(con.getOutputStream());
        entrada = new BufferedReader(new InputStreamReader(con.getInputStream()));
        conexionesRealizadas++;
        System.out.println("Servidor : Conexion aceptada a Cliente " +conexionesRealizadas);
        /*leer primer mensaje, peticion de inicio de juego desde el cliente.*/
        leerMensaje(entrada.readLine());
        // imprimirEntrada();
        procesarMensaje();
        salida.writeBytes(responderMensaje());
        // imprimirSalida();
        }} else {
         entrada = new BufferedReader(new InputStreamReader(con.getInputStream()));
         salida = new DataOutputStream(con.getOutputStream());
         //EL SOCKET ESTA OCUPADO, POR LO TANTO SE ESTA EN JUEGO
         if (estadoJuego == JUGANDO) {
         leerMensaje(entrada.readLine());
         // imprimirEntrada();
         procesarMensaje();
         salida.writeBytes(responderMensaje());
         // imprimirSalida();
         if (estadoJuego == GANO || estadoJuego == PERDIO) {
         estadoJuego = INACTIVO;SocketDisponible = true;
         System.out.println("Juego numero " + conexionesRealizadas + "Terminado.");
         }}}
       } catch (java.net.SocketException e) {
        System.out.println("Termino abrupto de la comunicacion con el cliente.");
     estadoJuego = INACTIVO;
     SocketDisponible = true;
     System.out.println("Juego numero " + conexionesRealizadas + " Terminado.");}}
   } catch (IOException BindException) {
       System.out.println("La maquina virtual de java ya esta ocupando el socket"+ "en ese puerto, intente iniciar el servicio con otro puerto");}}
   
private static void leerMensaje(String mensaje) {
            StringTokenizer stk = new StringTokenizer(mensaje, "#");
   while (stk.hasMoreTokens()) {
       estadoJuego = Integer.valueOf(stk.nextToken());
    nroIntentos = Integer.valueOf(stk.nextToken());
    letra = stk.nextToken().toUpperCase().charAt(0);
    palabraEnProgreso = stk.nextToken().toUpperCase();
    nroMensaje = Integer.valueOf(stk.nextToken());}
   nroMensaje++;}
  
private static void procesarMensaje() {
            if (estadoJuego == SOLICITANDO_JUEGO_NUEVO) {
       setSocketDisponible(false);
    setEstadoJuego(JUGANDO);
    setNroIntentos(6);
    setLetra('?');
    setPalabra(escojerPalabraJuegoNuevo());
    setPalabraEnProgreso();
   } else {
     if (estadoJuego == JUGANDO) {
         if (huboAcierto()) {
       reemplazarLetra();
       if (ganoJuego()) {estadoJuego = GANO;
       System.out.println("Servidor : Cliente ha ganado el juego");}
             else {System.out.println("Servidor : Cliente ha acertado la palabra");}}
         else {
      nroIntentos--;
      System.out.println("Servidor : Se le ha disminuido un intento al cliente por no haber acertado");
      if (nroIntentos == 0) {
       estadoJuego = PERDIO;
       System.out.println("Servidor : Cliente ha perdido el juego");}}}
      else {
        try {
         System.out.println("Servidor : cerrando conexion...");
      con.shutdownOutput();
      SocketDisponible = true;
      System.out.println("Servidor : Conexion finalizada.");
     } catch (IOException ex) {
       Logger.getLogger(ServidorTCP.class.getName()).log(Level.SEVERE, null, ex);}}}
 }
private static String responderMensaje() {
            String a = estadoJuego + "#" + nroIntentos + "#" + letra + "#" + palabraEnProgreso + "#" +nroMensaje + "\n";
   return a;}
  
public static void setSocketDisponible(boolean SocketDisponible) {
           ServidorTCP.SocketDisponible = SocketDisponible;
  }
 
public static void setConexionesRealizadas(int conexionesRealizadas) {
          ServidorTCP.conexionesRealizadas = conexionesRealizadas;}
   
public static void setEstadoJuego(int estadoJuego) {
          ServidorTCP.estadoJuego = estadoJuego;}
   
public static void setLetra(char letra) {
          ServidorTCP.letra = letra;}
   
public static void setNroIntentos(int nroIntentos) {
          ServidorTCP.nroIntentos = nroIntentos;}
   
public static void setPalabra(String palabra) {
          ServidorTCP.palabra = palabra;}
   
public static void setPalabraEnProgreso(String palabraEnProgreso) {
           ServidorTCP.palabraEnProgreso = palabraEnProgreso;}
    
private static String escojerPalabraJuegoNuevo() {
          return palabrasAhorcado[(int) (Math.random() * palabrasAhorcado.length)];}
   
private static void setPalabraEnProgreso() {
          String p = "";
    for (int i = 0; i < palabra.length(); i++) {
        p += "_";}
     palabraEnProgreso = p;}
    
private static boolean huboAcierto() {
         boolean tuvoAcierto = true;
   //PRIMERO DEBEMOS COMPROBAR QUE LA LETRA NO SE REPITA CON LO QUE YA TENEMOS COMPLETADO ACTUALMENTE
   tuvoAcierto = !seRepite(letra, palabraEnProgreso) && esParteDeLaPalabra(letra, palabra);
   return tuvoAcierto;}
  
private static boolean seRepite(char l, String enProgreso) {
         boolean repite = false;
   char[] prog = enProgreso.toCharArray();
   for (int i = 0; i < prog.length; i++) {
       if (l == prog[i]) {repite = true;}}
      return repite;}
  
private static boolean esParteDeLaPalabra(char letra, String palabra) {
         boolean esParte = false;
   char[] pa = palabra.toUpperCase().toCharArray();
   for (int i = 0; i < pa.length; i++) {
       if (letra == pa[i]) {esParte = true;}}
  return esParte;}
 
private static void reemplazarLetra() {
         String[] enProg = palabraEnProgreso.split("");
   String[] pal = palabra.split("");
   String reemplazada = "";
   for (int i = 0; i < pal.length; i++) {
       if (String.valueOf(letra).equalsIgnoreCase(pal[i])) {
        enProg[i] = String.valueOf(letra);}
       reemplazada += enProg[i];}
   palabraEnProgreso = reemplazada;}
  
private static boolean ganoJuego() {
         if (palabraEnProgreso.equalsIgnoreCase(palabra)) {
   return true;}
   else {return false;}}
  
private static String mostrarEstado() {
    if (estadoJuego == 0) {return "INACTIVO";}
 else {if (estadoJuego == 1) {
    return "JUGANDO";}
 else {if (estadoJuego == 2) {
     return "GANO";}
    else {if (estadoJuego == 3) {
     return "PERDIO";}
 else {if (estadoJuego == 4) {
     return "SOLICITANDO_JUEGO_NUEVO";}
 else {
     return "JUEGO_TERMINADO";}}}}}}
 
private static void imprimirEntrada() {
    String a = estadoJuego + "#" + nroIntentos + "#" + letra + "#" + palabraEnProgreso + "#" +nroMensaje;
 System.out.println("\nLeído por Servidor: " + a + "\n" + mostrarEstado());}

private static void imprimirSalida() {
    String a = estadoJuego + "#" + nroIntentos + "#" + letra + "#" + palabraEnProgreso + "#" +nroMensaje;
 System.out.println("\nEnviado por Servidor: " + a + "\n" + mostrarEstado());}

}

Juego Ahorcado Distribuido

Interfaz del Ahorcado:

public interface ClienteAhorcadoint{
 
 public  void enviarMensaje();
 public  String crearMensajeRespuesta();
 public  int getEstadoJuego();
 public  char getLetra();
 public  int getNroIntentos();
 public  String getPalabraEnProgreso();
 public  void setEstadoJuego(int estadoJuego);
 public  void setLetra(char letra);
 public  void leerMensaje(String mensaje);
 public  void imprimirMensajeEnPantalla();
 public String getPalabraActualGuionBajo();
 public  String mostrarEstado();
 public  void imprimirEntrada();
 public  void imprimirSalida();
}
 

Implementación de la Interfaz del Ahorcado:

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.StringTokenizer;

public class ClienteAhorc implements ClienteAhorcadoint {
private static final int INACTIVO = 0;
private static final int JUGANDO = 1;
private static final int GANO = 2;
private static final int PERDIO = 3;
private static final int SolicJuegoNuevo = 4;
private static final int JuegoTerminado = 5;
private static final int puerto = 10028;
private static BufferedReader in = null;
private static DataOutputStream out = null;
private static Socket conexion;
private static int edoJuego = INACTIVO;
private static int intentRest = 6;
private static char letra = '*';
private static String palabraEnProgreso = "*";
private static Integer numMensaje = 0;
public static void main(String[] args) {
try {
     ClienteAhorc Ahcd = new ClienteAhorc();
     conexion = new Socket("192.168.15.132", 10028);
  BufferedReader entradaUsuario = new BufferedReader(new InputStreamReader(System.in));
  System.out.println("Iniciando Conexion con servidor...");
  in = new BufferedReader(new InputStreamReader(conexion.getInputStream()));
  out = new DataOutputStream(conexion.getOutputStream());
  System.out.println("Conexion realizada...");
  boolean jugando = true;
  while (jugando == true) {
      if (edoJuego == INACTIVO) {
       Ahcd. setEstadoJuego(SolicJuegoNuevo);
    Ahcd.enviarMensaje();
    } else {
       Ahcd.leerMensaje(in.readLine());
       if (edoJuego == JUGANDO) {
     Ahcd.imprimirMensajeEnPantalla();
     System.out.println("Ingrese una letra: ");
     Ahcd.setLetra(entradaUsuario.readLine().charAt(0));
     Ahcd.enviarMensaje();
     } else {
        if (edoJuego == GANO) {
        Ahcd. setEstadoJuego(JuegoTerminado);
        Ahcd.imprimirMensajeEnPantalla();
        jugando = false;
        System.out.println("¡Felicidades! Ganaste en el juego de Ahorcado");
        }
        if (edoJuego == PERDIO) {
         Ahcd. setEstadoJuego(JuegoTerminado);
         Ahcd.imprimirMensajeEnPantalla();
         jugando = false;
         System.out.println("Lastima, no te quedan mas intentos.\nHas perdido");
        }
      System.out.println("Juego terminado");
       }
    }
   }
 }catch (IOException ex) {
    System.out.println("Error de Entrada/Salida");
    System.out.println("No fue posible realizar la conexion, posiblemente el servidor este inactivo.");
    }
}

public  void enviarMensaje() {
  ClienteAhorc Ahcd = new ClienteAhorc();
  try {
     if (edoJuego == SolicJuegoNuevo) {
      out.writeBytes(Ahcd.crearMensajeRespuesta());
  } else {
   out.writeBytes(Ahcd.crearMensajeRespuesta());
   }
 }catch (IOException iOException) {
     System.out.println("Error al enviar el mensaje");
  }
}
 
public  String crearMensajeRespuesta() {
    return edoJuego + "#" + intentRest + "#" + letra + "#" + palabraEnProgreso + "#" +numMensaje + "\n";
 }

public  int getEstadoJuego() {
    return edoJuego;
 }

public  char getLetra() {
    return letra;
 }

public  int getNroIntentos() {
    return intentRest;
 }
public  String getPalabraEnProgreso() {
    return palabraEnProgreso;
 }
public  void  setEstadoJuego(int edoJuego) {
    ClienteAhorc.edoJuego = edoJuego;}
public  void setLetra(char letra) {
    ClienteAhorc.letra = letra;
 }
public  void leerMensaje(String mensaje) {
  StringTokenizer stk = new StringTokenizer(mensaje, "#");
  while (stk.hasMoreTokens()) {
      edoJuego = Integer.valueOf(stk.nextToken());
   intentRest = Integer.valueOf(stk.nextToken());
   letra = stk.nextToken().charAt(0);
   palabraEnProgreso = stk.nextToken();
   numMensaje = Integer.valueOf(stk.nextToken());
   }
 }
  
public  void imprimirMensajeEnPantalla() {
    ClienteAhorc Ahcd = new ClienteAhorc();
 System.out.println("^^^^^^^^^^^ Ahorcado ^^^^^^^^^^^");
 imprimirAhorcado(intentRest);
 System.out.println("\nPalabra actual: " + Ahcd.getPalabraActualGuionBajo());
 System.out.println("Intentos restantes: " + intentRest);
 }
public  String getPalabraActualGuionBajo() {
    String[] a = palabraEnProgreso.split("");
 String impr = "";
 for (int i = 0; i < a.length; i++) {
     impr += a[i] + " ";}
 return impr;
 }

public  String mostrarEstado() {
    if (edoJuego == 0) {
     return "INACTIVO";}
    else {
     if (edoJuego == 1) {
  return "JUGANDO";}
 else {
     if (edoJuego == 2) {
  return "GANO";}
 else {
     if (edoJuego == 3) {
  return "PERDIO";}
 else {
     if (edoJuego == 4) {
  return "SolicJuegoNuevo";}
 else {
     return "JuegoTerminado";}}}}}}

public  void imprimirEntrada() {
    ClienteAhorc Ahcd = new ClienteAhorc();
    String a = edoJuego + "#" + intentRest + "#" + letra + "#" + palabraEnProgreso +"#" + numMensaje;
 System.out.println("Leido por el cliente: " + a + "\n" + Ahcd.mostrarEstado());}

public  void imprimirSalida() {
    ClienteAhorc Ahcd = new ClienteAhorc();
    String a = edoJuego + "#" + intentRest + "#" + letra + "#" + palabraEnProgreso +"#" + numMensaje;
 System.out.println("Enviado por el cliente: " + a + "\n" + Ahcd.mostrarEstado());}
public  void imprimirAhorcado(int intentRest) {
    System.out.println(" ________________");
 if (intentRest < 1) {
  System.out.println("|   |");
  System.out.println("|   |");
  System.out.println("|   O");
  System.out.println("|  \\|/");
  System.out.println("|   |");
  System.out.println("|  /|\\");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
  }
 else {
     if (intentRest < 2) {
  System.out.println("|   |");
  System.out.println("|   |");
  System.out.println("|   O");
  System.out.println("|  \\|/");
  System.out.println("|   |");
  System.out.println("|  /|");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
   }
 else {
      if (intentRest < 3) {
  System.out.println("|   |");
  System.out.println("|   |");
  System.out.println("|   O");
  System.out.println("|  \\|/");
  System.out.println("|   |");
  System.out.println("|   |");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
   }
 else {
      if (intentRest < 4) {
  System.out.println("|   |");
  System.out.println("|   |");
  System.out.println("|   O");
  System.out.println("|  \\|");
  System.out.println("|   |");
  System.out.println("|   |");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
   }
 else {
      if (intentRest < 5) {
  System.out.println("|  |");
  System.out.println("|  |");
  System.out.println("|  O");
  System.out.println("|  |");
  System.out.println("|  |");
  System.out.println("|  |");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
   }
 else {
      if (intentRest < 6) {
  System.out.println("|  |");
  System.out.println("|  |");
  System.out.println("|  O");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
   }
 else {
      if (intentRest < 7) {
  System.out.println("|  |");
  System.out.println("|  |");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
  System.out.println("|");
   }}}}}}}
 System.out.print("----------------------------");}
}

Modelo OSI

Introducción.

Como ya vimos antes, la comunicación entre personas necesita de unos pasos a seguir, y la comunicación entre dispositivos en red también los necesita, solo que se conocen como protocolos. El protocolo de comunicación que usaremos es el modelo OSI, que se compone de siete capas que se describirán hoy. Sin embargo, primero es importante saber que es un protocolo de comunicación y uno compuesto de capas.

Protocolo de comunicación.

Un protocolo de comunicación es una serie de lineamientos y reglas estrictas de procedimientos cuya función sea que el intercambio de datos entre componentes a través de la red sea de forma ordenada (Pérez, 2003).

Protocolos de comunicación de capas.

Los protocolos de comunicación de capas están implementados para la operación de sistemas abiertos, esto significa que todos los sistemas serán compatibles, y que la interconexión de redes será viable. Su objetivo es definir las funciones de telecomunicaciones y separarlas en conjuntos (capas) de subfunciones. Cada capa realiza una tarea distinta y autosuficiente, sin embargo, depende de las capas inferiores.

La mayoría de los protocolos de transferencia de datos de uso actual utilizan protocolos de capas. Cada capa se comunica con su igual en el otro sistema por medio de un protocolo. Sin embargo, la comunicación se da usando los servicios de la capa inferior. La comunicación entre una capa y su antecesora se conoce como interfaz. Así, cada capa presta sus servicios a la capa superior y utiliza los de la capa inferior. La información fluye de manera “lógica” horizontalmente usado protocolos, y en “forma real” verticalmente sobre interfaces. Un protocolo conecta siempre dos entidades al mismo nivel, mientras que la interfaz acopla capas de una misma entidad (Pérez, 2003).

Modelo OSI.

El modelo de Interconexión de sistemas abiertos (OSI: Open Systems Interconnection) fue diseñado por la Organización para la Estandarización Internacional (ISO: International Standard Organization) y permite que dos sistemas distintos se comuniquen sin importar su arquitectura. Se compone de siete capas, cada una con funcionalidades independientes pero relacionadas.



Modelo de interconexión de sistemas abiertos (OSI).

La figura siguiente muestra la transmisión de datos de un dispositivo A a uno B. Antes de que se envíen los daos al medio de trasmisión, estos se desplazan había abajo a través de las siete capas hasta llegar  a la física. En cada capa se añade información de control a los datos en forma de encabezados (headers) o caracteres de control (trailers). Los encabezados se añaden a los datos en las capas 7, 6, 5, 4, 3 y 2, mientras que los caracteres de control se añaden en la capa 2. En la maquina receptora, el encabezado y los caracteres de control se dejan caer mientras se avanza hacia la capa 7.

A continuación se describen brevemente las funciones de cada capa.

1.  Capa Física. Es la responsable de trasmitir los datos en forma de señales (grupos de bits) a través de un medio físico de un dispositivo a otro.

2.  Capa de Enlace de datos. Organiza los grupos de bits en unidades lógicas llamadas bloques de datos (frames). Añade un encabezado y caracteres de control que definen el bloque e información que define su direccionamiento. Además puede detectar errores en los datos y corregirlos

3.  Capa de Red. Envía los paquetes de datos al exterior, independientes uno del otro. Es responsable de la entrega de un nodo a otro de los paquetes de datos entre el origen y su destino final a los que les agrega un encabezado que contiene una dirección de origen y una destino (dirección lógica o IP, que permanece intacta).

4.  Capa de Transporte. Es el responsable de asegurar que se transmita del origen al destino el mensaje completo (conjunto de paquetes de datos). Se encarga de dividir el mensaje en paquetes y entregarlos a la capa de red.

5.  Capa de Sesión. Establece, mantiene y sincroniza el dialogo entre los sistemas. Añade puntos de sincronización que respaldan la entrega de los mensajes en caso de un fallo en la red. Estos puntos de sincronización dividen un mensaje largo en partes de mensaje, para que en caso de fallo no se reenvíe el mensaje completo, sino se desplace al último punto de sincronización y comenzar desde ahí.

6.  Capa de Presentación. Se encarga de darle una misma sintaxis (formato) y semántica (significado) a la información intercambiada. Comprime y descomprime los datos para conseguir un mejor rendimiento y los cifra y descifra por motivos de seguridad.

7.  Capa de Aplicación. Permite que el usuario (persona o software) accese a la red mediante servicios que simplifiquen el trabajo del usuario.

Conclusión.

Como ya vimos, el modelo OSI se creó para estandarizar la comunicación y transmisión de datos entre los dispositivos de una red. Este modelo lo ocupamos siempre que utilizamos aplicaciones que necesitan la comunicación entre nosotros y otra persona en otro lugar, y esto se da mediante el uso de una red. Es importante conocer y manejar cada capa de este modelo ya que lo utilizaremos a lo largo del curso.

Referencias.

Forouzan, B. A., & Chung Fegan, S. (2003). Foundations of computer science: from data manipulation to theory of computation. Estados Unidos: Brooks Cole.

Pérez, E. H. (2003). Tecnologías y Redes de transmisión de datos. México: Editorial Limusa.

Descargar Modelo OSI en PDF.

Redes y Topología

Introducción.

Como ya vimos, los sistemas distribuidos necesitan de las redes, pero ¿Qué es una red?

Una red es la interconexión de elementos de procesamiento que les permite a las personas compartir información y procesos y que pueden tener varios diseños.

A continuación veremos más a fondo que es una red, los tipos de redes que existen y su topología.

Red.

Una red es un medio que permite a personas o grupos compartir información y servicios. Está constituida por equipos llamados nodos que se comunican utilizando protocolos o lenguajes comprensibles para todos. (Dordoigne & Atelin, 2006). En una red es imprescindible identificar los ordenadores que forman parte de la misma. Cuando un ordenador genera una trama para otro, además de los datos que le quiere enviar, le pone el identificador del ordenador (u ordenadores) destino y el suyo, para que quien reciba la trama pueda saber quién se la ha enviado. (Barceló Ordinas & Íñigo Griera, 2004).

Hay tres tipos de redes: LAN, MAN Y WAN (S. Tanenbaum, 2003):

Red de área local LAN (Local Area Network, por sus siglas en inglés) es una red de propiedad privada que se encuentra en un edificio o en un campus de pocos kilómetros de longitud. Se utiliza para conectar computadoras personales y estaciones de trabajo para compartir recursos (como impresoras) e intercambiar información. Este tipo de red está restringido por su tamaño.

 

Red de área metropolitana MAN (Metropolitan Area Network) abarca una ciudad. Garantiza las comunicaciones sobre distancias más extensas y a menudo interconecta varias redes LAN. Puede servir para interconectar, por una conexión privada o pública, diferentes departamentos distantes a algunas decenas de kilómetros. (Dordoigne & Atelin, 2006)

Red de área amplia WAN (Wide Area Network) abarca una gran área geográfica (país o continente). Contiene un conjunto de maquinas (hosts) diseñado para programas de usuario. Estos hosts están conectados por una subred, la cual tiene como función llevar mensajes de un host a otro. La mayoría de estas redes consta de dos componentes: líneas de transmisión que mueven bits entre maquinas mediante cables de cobre, fibra óptica, etc., y los elementos de conmutación, que son maquinas llamadas routeadores o mutadores que conectan tres o más líneas de transmisión.

Alcance territorial de los diferentes tipos de redes.

Topología.

Las topologías de red describen la distribución física de la red. Es el patrón de interconexión entre los nodos de una red de computadoras o servidores, mediante la combinación de estándares y protocolos. Se busca máxima fiabilidad del tráfico de información, bajo costo y rendimiento óptimo para el usuario (tiempo de respuesta corto) (Sandoval Castelán, 2011).

Existen muchos tipos de topologías, pero a continuación solo se mencionarán cuatro (Jamrich Parsons & Oja, 2008):

Topología de Estrella: Las computadoras se conectan a un HUB o concentrador, y es éste quien controla el acceso al medio físico. Es muy usado ya que es fácil agregar o quitar computadoras. Una de sus ventajas es que si falla uno de los componentes (que no sea el central), el sistema sigue trabajando.

 

Topología de Anillo: Conecta todos los dispositivos en un círculo, y cada dispositivo tiene exactamente dos vecinos. Los datos se transmiten de un dispositivo a otro alrededor del anillo. Esta topología reduce el cableado pero la falla de un dispositivo afecta a toda la red.

 

Topología en Bus: Emplea una columna vertebral común para conectar todos los dispositivos de la red. Dicha columna vertebral funciona como un vínculo compartido de comunicaciones para trasladar los datos de la red. La columna se detiene en cada extremo de la red con un dispositivo especial llamado terminador. Este tipo de redes funcionan mejor con un número limitado de dispositivos. Además de que si falla la columna vertebral, se inutiliza toda la red.

 

Topología de Malla: En esta topología se conecta cada dispositivo de la red a muchos otros dispositivos de la red. Los datos que se desplazan pueden conseguir varias trayectorias posibles de su lugar de origen a su destino. Estas trayectorias de datos redundantes hacen muy robusta a la red. Incluso si fallan varios vínculos, los datos pueden seguir otros vínculos para llegar a su destino.

 

Conclusión.

Ahora que se conoce más acerca de los tipos de redes y la forma en que pueden estar dispuestas, es más fácil comprender como se transfiere la información y se ejecutan procesos entre dispositivos sin tener que estar uno al lado del otro. Ya que siempre estamos involucrados en redes, es esencial conocer y comprender su funcionamiento.

Referencias.

Barceló Ordinas, J. M., & Íñigo Griera, J. (Marzo de 2004). Universitat Oberta de Catalunya. Recuperado el 22 de Agosto de 2013, de Redes de Computadores: http://www.sw-computacion.f2s.com/Linux/011-Redes_computacionales.pdf

Dordoigne, J., & Atelin, P. (2006). Redes informáticas: Conceptos fundamentales. Barcelona: Ediciones ENI.

Jamrich Parsons, J., & Oja, D. (2008). Conceptos de computación: Nuevas perspectivas. México: CENGAGE Learning.

S. Tanenbaum, A. (2003). Redes de computadoras (Cuarta edicion ed.). México: Pearson.

Sandoval Castelán, E. (Julio de 2011). Universidad Autónoma del Estado de Hidalgo. Licenciatura en Sistemas Computacionales. Recuperado el 24 de Agosto de 2013, de Topologías de red: http://www.uaeh.edu.mx/docencia/P_Presentaciones/huejutla/sistemas/redes/topologias.pdf

 

Descargar "Redes y Topología" en PDF.

 

La comunicación y sus componentes.

Introducción.

La comunicación la usamos todos los días todo el día, para pedir o dar información, para obtener servicios, etc. y esta se da en distintos ambientes, usando diferentes canales y medios dependiendo el contexto.

Para que se dé una comunicación se necesita de un emisor y de un receptor, entre los que se dará el intercambio de información y que se debe dar de manera exitosa.

A continuación se define que es la comunicación y sus componentes.

Comunicación.

Una definición muy adecuada y completa es la siguiente: “La comunicación ocurre cuando un organismo (la fuente) codifica una información en señales y pasa a otro organismo (el receptor) que decodifica las señales y es capaz de responder adecuadamente”. Esta definición es aplicable a cualquier tipo de relación. (DeFleur, 1997).

Los componentes que integran la comunicación son a) emisor, b) mensaje, c) codificación-decodificación, d) canal, y e) receptor (Berlo, 1987).

Diagrama de la comunicación

 

Aunque dichos elementos que integran a la comunicación son parte de la rutina y vida diaria, no siempre se tiene un concepto claro de cada uno de ellos, por lo que es importante definirlos de manera clara y concisa.

Emisor y receptor: Estos comparten un mismo código, en base al cual pueden establecer una comunicación relativa a un referente. Esta intercambiabilidad es marcada por el propio proceso bidireccional de la comunicación (Fernández de Motta, 2013).

Mensaje: Berlo lo considera como: “La expresión de las ideas (contenido), de una forma determinada (tratamiento) y mediante el empleo de un código. Este código realiza la función de transferir el contenido de la información de un sistema emisor a un sistema receptor, gracias a una transformación determinada” (Berlo, 1987).

Código: Es definido por Berlo como "Todo grupo de símbolos que puede ser estructurado, de manera que tenga algún significado para alguien" (Berlo, 1987).

Codificación - Descodificación: Para Serrano, la codificación es "Un proceso de producción de mensaje por el emisor", mientras que la descodificación la define como "La re-traducción del mensaje con el fin de extraer su significado; es el uso del código por el receptor para interpretar el mensaje" (Serrano, 1992).

Canal: Serrano lo define como “El medio físico gracias a cuya estructuración, se transmite el mensaje” (Serrano, 1992) y Berlo lo considera como “Formas de encodificar y decodificar mensajes, vehículos de mensajes, y medio de transporte” (Berlo, 1987).

 

Conclusión.

Por lo visto anteriormente, es muy importante comprender los elementos involucrados en la comunicación, ya que siempre hacemos uso de ellos.

En los sistemas distribuidos es muy importante la comunicación entre los dispositivos que forman parte de la red o del sistema, ya que uno de sus objetivos es efectuar procesos e intercambiar información (datos) entre ellos, y para esto se requiere de comunicación.

Referencias.

Berlo, D. K. (1987). El proceso de la comunicación. Introducción a la teoría y la práctica. Buenos Aires: El Ateneo.

DeFleur, M. L. (1997). Fundamentals of Human Communication. Mountain View, CA: Mayfield Publishing.

Fernández de Motta, M. d. (2013). Concepto de comunicación y componentes del proceso comunicativo. EFDeportes.com, Revista Digital (178).

Serrano, S. (1992). La Semiótica. Una introducción a la teoría de los signos (Cuarta Edición ed.). Barcelona: Montecinos.

 

Descargar Comunicación en PDF.

 

 

Descargar archivo PDF de los Sistemas Distribuidos

Sistemas Distribuidos

Introducción.

Un Sistema Distribuido es un sistema de computadoras en interconexión, que se comportan como una sola a pesar de estar compuestas por varios elementos. Al estar todas ellas en una red, el usuario puede consultar información sin importar si ésta se originó en otra computadora, ya que todas pueden tener acceso a la misma información y a los mismos procesos.

Este es el objetivo de los sistemas distribuidos, el establecer una comunicación Cliente-Servidor y el compartimiento de recursos de manera eficiente, segura y rápida. Todo esto se logra mediante el uso de mensajes entre las partes.

Sistemas Distribuidos.

“Un sistema en el que los componentes hardware y/o software ubicados en computadores en red, se comunican y coordinan sus acciones intercambiando mensajes.” (Coulouris, Dollimore, Kindberg, & Blair, 2011)

En cuanto a las características de los sistemas distribuidos, se pueden encontrar variedad de ellas. Estas son algunas características importantes:

Ø  Estado compartido: Todas las computadoras tienen la misma visión y acceso a la información, procesos y recursos solicitados.

Ø  Fiable: Es la capacidad del sistema para realizar correctamente y en todo momento las funciones para las que se ha diseñado.

Ø  Eficiente: Para lograr que un sistema como este sea eficiente hay que poner en práctica la idea de ejecutar un programa en un único procesador del sistema y, entonces, distribuir las tareas a realizar por éste en varios procesadores

Ø  Transparencia: El usuario y los programas ven al sistema como un todo, sin importar las diferentes ubicaciones de las computadoras que lo integran.

Ø  Escalable: Un sistema es escalable si conserva su efectividad cuando ocurre un incremento significativo en el número de recursos y número de usuarios

Ø  Heterogéneo: Esta característica es muy importante. Significa que el sistema puede trabajar con diversidad de plataformas, de lenguajes de programación, de redes, etc. sin ser esto motivo de problema.

El siguiente mapa conceptual muestra todo lo anterior de una forma mucho más simple.

Conclusión.

Yo considero que los sistemas distribuidos están presentes en nuestra vida cotidiana y forman parte importante de ella, ya que siempre estamos utilizándolos aunque no nos percatemos de esto. En las acciones más simples y cotidianas como checar correos están los sistemas distribuidos, esto se puede observar al utilizar el servicio de mensajería en el que observamos todos nuestros correos, pero en realidad no sabemos si todos estos están en un mismo lugar o se encuentran en varias ubicaciones pero nos da la impresión de que es un solo sistema.

Referencias.

Coulouris, G., Dollimore, J., Kindberg, T., & Blair, G. (2011). Sistemas Distribuidos: Conceptos y Diseño. Adisson Wesley.

García Izquierdo, F. J. (s.f.). Universidad de la Rioja. Departamento de Matemáticas y Computación. Recuperado el 08 de Agosto de 2013, de Introducción a la computación: http://www.unirioja.es/cu/fgarcia/sd/pub/teo/01-IntroduccionALaComputacionDistribuida.pdf

Lafuente, A. (s.f.). Universidad del País Vasco. Departamento de Arquitectura y Tecnología de Computadores. Recuperado el 08 de Agosto de 2013, de Introducción a los Sistemas Distribuidos: http://www.sc.ehu.es/acwlaroa/SDI/Apuntes/Cap1.pdf

Universidad Politécnica de Cataluña. Departamento de Arquitectura de Computadoras. (Septiembre de 2005). Recuperado el 08 de Agosto de 2013, de Conceptos generales de Sistemas Distribuidos: http://studies.ac.upc.edu/EPSC/FSD/FSD-ConceptosGenerales.pdf