TECNOLÓGICO NACIONAL DE MÉXICO

INSTITUTO TECNOLÓGICO DE TAPACHULA

ASIGNATURA:
TALLER DE SISTEMAS OPERATIVOS

INVESTIGACIÓN:
SISTEMAS OPERATIVOS DISTRIBUIDOS

DOCENTE:
HOMERO HERRERA ROJAS

ALUMNO:
GARCIA CAMPUZANO MIGUEL ANGEL

CARRERA:
INGENIERÍA EN SISTEMAS
COMPUTACIONALES

SEMESTRE:
VI

Tapachula, chis a 03 de Junio del 2019

ÍNDICE
INTRODUCCIÓN...............................................................................................................3
DEFINICIÓN.....................................................................................................................4
OBJETIVOS.......................................................................................................................5
CLASIFICACIÓN................................................................................................................5
RESPECTO AL MODO DE TRABAJO DEL USUARIO............................................................................5
RESPECTO AL NÚMERO DE USUARIOS......................................................................................... 5
RESPECTO AL PROPÓSITO.........................................................................................................6
MODELOS DE SISTEMA DISTRIBUIDO..........................................................................................6
Estaciones y servidores...................................................................................................6
Banco de procesadores...................................................................................................6
Miniordenadores Integrados..........................................................................................7
Modelos híbridos............................................................................................................7
ARQUITECTURAS.............................................................................................................8
MODELO CLIENTE - SERVIDOR...................................................................................................8
CLÚSTER...............................................................................................................................9
ARQUITECTURA DE CAPAS......................................................................................................10
CORBA............................................................................................................................. 11
SISTEMAS BASADOS EN OBJETOS DISTRIBUIDOS...........................................................12
SISTEMAS DE ARCHIVOS DISTRIBUIDOS.........................................................................14
SISTEMA NFS (NETWORK FILE SYSTEMS).................................................................................14
Inconvenientes del NFS.................................................................................................14
SISTEMA AFS (ANDREW FILE SYSTEMS)...................................................................................15
CONCLUSIÓN.................................................................................................................17
REFERENCIAS.................................................................................................................18
Introducción

En años recientes, el avance en las tecnologías de cómputo y las

telecomunicaciones han permitido una gran expansión de los sistemas de
información, así como su alta disponibilidad, independientemente de su campo de
aplicación. Las telecomunicaciones permiten la conectividad de un gran número
de usuarios ubicados en cualquier parte del mundo por medio de la transmisión de
voz, datos o video a través de una gran variedad de dispositivos. Diferentes redes
de comunicación de área local (LAN), metropolitanas (MAN), así como de área
amplia (WAN), pueden ser accedidas a través de Internet. Esto ha permitido que
paralelamente surjan instalaciones de cómputo donde pueden ser desplegadas
aplicaciones para realizar procesamiento distribuido de tareas. Estas nuevas
facilidades ofrecen a los usuarios y organizaciones una gran flexibilidad para
estructurar sus propios sistemas de información de una manera eficiente, así
como la oportunidad de interactuar con otros sistemas de información de una
manera distribuida. Como consecuencia, esto ha generado una gran dependencia
de estos sistemas distribuidos para poder transmitir o procesar información.
Tanenbaum [1996] define un sistema distribuido como una colección de
computadoras independientes que aparecen ante los usuarios del sistema como
una única computadora. El advenimiento de los sistemas distribuidos ha estado
soportado en dos importantes innovaciones tecnológicas: • El microprocesador y •
Las redes de área local. [ CITATION Lóp15 \l 2058 ]
Definición
Es un software que administra una colección de Nodos Computacionales que
trabajan en Red, se comunican entre ellos y están físicamente separados.
[ CITATION HER19 \l 2058 ].

Los sistemas operativos distribuidos abarcan los servicios de los de red, logrando
integrar recursos (impresoras, unidades de respaldo, memoria, procesos,
unidades centrales de proceso) en una sola máquina virtual que el usuario aceza
en forma transparente. Es decir, ahora el usuario ya no necesita saber la ubicación
de los recursos, sino que los conoce por nombre y simplemente los usa como si
todos ellos fuesen locales a su lugar de trabajo habitual.[ CITATION Rin19 \l
2058 ].

Diferencias entre Sistemas

La diferencia fundamental entre un sistema en red y uno distribuido se puede
explicar a través del análisis de la localización del módulo de comunicaciones
entre procesos.
Un sistema en red típico es una colección de sistemas operativos locales,
acompañado de servidores de impresión y de archivos, conectados por medio de
una red. Los usuarios están enterados de la multiplicidad de máquinas y para el
acceso a los recursos necesitan conectarse a la máquina remota o transferir datos
de la máquina remota a la propia. Podemos decir que todos los sistemas en red se
ejecutan como funciones locales autónomas a la administración de dispositivos, de
procesos, de entradas y salidas, de archivos y recursos en general.
Estas funciones deben interactuar, pero tomando decisiones locales sin tener en
cuenta procesos y recursos remotos. Las decisiones y el control orientado a
operaciones remotas, son tomadas solo a nivel de la comunicación de la red.
Por otro lado podemos decir que un sistema distribuido es solo un sistema
expandido en toda la red, pero visto como un solo sistema para todos los
elementos que existen en la red. Los usuarios no necesitan saber de la
multiplicidad de máquinas y pueden acceder a los recursos remotos de la misma
manera que lo hacen para los recursos locales. La tolerancia a fallas es más alta,
pero también podemos decir que el control y las decisiones son tomados
globalmente, los recursos conectados a la red son administrados de una forma
global usando mecanismos distribuidos en lugar de mecanismos locales.

Objetivos
 Facilitar el acceso y la gestión de los recursos distribuidos en la red.
 Permitir que los usuarios pueden acceder a recursos remotos de la misma
manera en que lo hacen para los recursos locales.
 Distribuir trabajos, tareas o procesos, entre un conjunto de procesadores.

Clasificación
Respecto al modo de trabajo del usuario

Se pueden clasificar los sistema operativos, partiendo de este punto de vista, en

on line (o interactivos) y off line (o batch o por lotes). Como ejemplo de los
primeros ya hemos comentado los sistemas de tiempo compartido, los sistemas
interactivos son útiles, entre otros, en entornos de desarrollo de programas, de
procesamiento de textos y de ejecución de programas interactivos.
Un ejemplo de los segundos son los sistemas por lotes. Los sistemas batch se
caracterizan porque una vez introducida una tarea en el ordenador, el usuario no
mantiene contacto alguno con ella hasta que finaliza su ejecución.
Respecto al número de usuarios
Si se tiene en cuenta el número de usuarios se puede hablar de sistemas
monousuario y multiusuario (o multiacceso). En los primeros se puede acceder al
ordenador mediante un único terminal, frente a los varios terminales de acceso
simultáneo que permiten los segundos.
Ejemplos de sistemas operativos monousuario son MS DOS y CP/M. Un ejemplo
de sistema multiusuario es UNIX.
Respecto al propósito
Atendiendo al uso que quieran dar los usuarios al ordenador, los sistemas
operativos se pueden dividir en sistemas de propósito específico y sistemas de
propósito general.
Un ejemplo de sistema de propósito específico es un sistema de tiempo real, estos
sistemas se usan en entornos donde se deben aceptar y procesar en tiempo breve
un gran número de sucesos, en su mayoría externos al ordenador. Ejemplos de
tales aplicaciones incluyen control industrial, equipamiento telefónico conmutado,
control de vuelo y simulaciones en tiempo real.
Los sistemas de propósito general se caracterizan por tener un gran número de
usuarios trabajando sobre un amplio abanico de aplicaciones. Se suelen dividir en
dos grandes grupos: los de lotes y los de tiempo compartido. Sin embargo, existen
sistemas que compaginan el tiempo compartido con procesos por lotes.

Modelos de Sistema Distribuido

Estaciones y servidores
Es el más común en la actualidad. A cada usuario se le asigna una estación. Las
estaciones: ejecutan las aplicaciones. Dan soporte a la interfaz de usuario (GUI).
Acceden a los servicios compartidos, mediante SW de comunicaciones.
Los servidores dan acceso a: Información compartida (servicio de ficheros)
dispositivos HW compartidos (impresoras, scanners, ...) funciones del Sistema
Operativo (autentificación, ...) Ejemplos:
XDS y Cedar, del Xerox PARC.
V-system de la Universidad de Stanford.
Argus, del MIT.

Banco de procesadores
Los procesadores del pool tienen un CPU, suficiente memoria, pero no tienen ni
discos ni terminales. Los usuarios acceden al sistema desde terminales-X. Gestor
de recursos: controla el acceso a los procesadores del pool (PP). El usuario
especifica sus requerimientos (CPU, memoria, programa).
El Gestor de Recursos le asigna un procesador como ordenador personal.
Ventajas con respecto a Estaciones y Servidores: mejor utilización de recursos:
muchos puntos de entrada con pocas CPUs. Mayor flexibilidad: se pueden dedicar
procesadores para expandir servicios. Compatibilidad con el SW preexistente.
Utilización de procesadores heterogéneos.
Inconveniente: mala respuesta interactiva: terminales conectados a una línea
serie. Ejemplo: CDCS, basado en el anillo de Cambridge.

Miniordenadores Integrados
Basado en máquinas multiusuario. El usuario se conecta a una máquina
específica. Enfoques históricos: acceso remoto mediante copias: de esta forma no
se mezclan los espacios de nombramiento locales, pero no es distribuido.
Sistemas de ficheros contiguos:
Súper directorio virtual: "/../", esquema de nombramiento global.
No es distribuido: el nombre de los ficheros depende de su ubicación (máquina A,
B, C????)
ejemplo: NETIX, Newcastle Connection.

Modelos híbridos
AMOEBA, de la Universidad Libre de Amsterdam. Consiste en: sistema de
estaciones y servidores más un pool de procesadores. Funcionalidad mixta:
estaciones para las aplicaciones interactivas. Procesadores variados. Servidores
especializados. Características:
 Kernel pequeño: planificación y paso de mensajes.
 El SO corre como procesos de usuario.
 Servicio de Gateway a WAN.
 Gestión del pool mediante un servidor de carga y otro de procesos.
Ventajas:
Recursos de procesamiento ajustados a las necesidades del usuario.
Ejecución concurrente.
Acceso a través de terminales (precio).
Arquitecturas
Modelo cliente - servidor
El modelo cliente-servidor es la arquitectura más citada cuando se discuten los
sistemas distribuidos. Es el modelo más importante y sigue siendo el más
ampliamente utilizado. La figura 3.1 ilustra la estructura simple de esta
arquitectura, en la cual los procesos toman el rol de ser clientes o servidores. En
particular, los procesos de cliente interactúan con los procesos de servidor
individuales en equipos anfitriones (host) potencialmente separados, con el fin de
acceder a los recursos compartidos que administran.

Figura 3.1. Ejemplo de una estructura simple cliente-servidor

El modelo cliente-servidor puede tomar diferentes configuraciones. Por ejemplo,

puede existir más de un cliente conectado a un servidor, como se indica en la
figura 3.2. También se puede tener un grupo de servidores interconectados
dedicados a dar servicio a un grupo de clientes. Este escenario se indica en la
figura 3.3.

Figura 3.2. Ejemplo de estructura cliente-servidor para dos clientes

Figura 3.3. Grupo de
servidores interconectados basado en el modelo cliente-servidor

Clúster
En informática, el término clúster (“grupo” o “racimo”) hace referencia a conjuntos
o conglomerados de computadoras construidos mediante el uso de hardware
común y que se comportan como si fueran una única computadora. Un ejemplo de
clúster se muestra en la figura 3.9. El uso de los clústeres varía desde las
aplicaciones de supercómputo, servidores web y comercio electrónico hasta el
software de misiones críticas y bases de datos de alto rendimiento. El cómputo
con clústeres es el resultado de la convergencia de varias tendencias tecnológicas
actuales, entre las que se pueden destacar:
 Microprocesadores de alto rendimiento.
 Redes de alta velocidad.
 Software para cómputo distribuido de alto rendimiento.
 Crecientes necesidades de potencia computacional.

Un clúster es homogéneo cuando todas las computadoras tienen la misma

configuración en hardware y sistema operativo. Es semihomogéneo cuando las
computadoras tienen diferente rendimiento pero guardan una similitud con
respecto a su arquitectura y sistema operativo. Finalmente, un clúster es
heterogéneo cuando las computadoras tienen diferente hardware y sistema
operativo.
 Figura 3.9. Ejemplo de clúster

Arquitectura de capas
Una arquitectura de capa resulta familiar en los sistemas distribuidos y está
relacionado con la abstracción. Con este enfoque, un sistema complejo puede ser
dividido en cierto número de capas, donde las capas superiores hacen uso de los
servicios ofrecidos por las capas inferiores. De esta manera, una determinada
capa ofrece una abstracción de software, sin que las capas superiores o inferiores
a esta deban de estar al tanto de los detalles de implementación. En el caso de los
sistemas distribuidos, los servicios se organizan de una manera vertical como
capas de servicio. Un servicio distribuido puede ser proporcionado por uno o más
procesos del servidor, que interactúan entre sí y con los procesos de cliente para
mantener una visión de todo el sistema, coherente de los recursos del servicio.
Por ejemplo, el ajuste de hora entre clientes puede realizarse por un servicio de
hora de red a través de Internet, usando el protocolo de Tiempo de Red (NTP). Es
útil organizar este tipo de servicio en capas debido a la complejidad de los
sistemas distribuidos. Una visión común de una arquitectura de capa se muestra
en la figura 3.11.
 Figura 3.11. Capas de servicio en un sistema distribuido [Coulouris et al., 2012]

CORBA
El paradigma orientado a objetos juega un importante rol en el desarrollo de
software y cuenta con gran popularidad desde su introducción. La orientación a
objetos se comenzó a utilizar para el desarrollo de sistemas distribuidos en la
década de 1980. El Grupo de Gestión de Objetos (OMG-Object Management
Group) se creó en 1989 como una asociación de las empresas líderes de la
tecnología software para definir especificaciones que puedan ser implementadas
por ellas y que faciliten la interoperabilidad de sus productos. Los middlewares
basados en componentes se han convertido en una evolución natural de los
objetos distribuidos, debido a que apoyan la gestión de las dependencias entre
componentes, ocultando los detalles de bajo nivel asociados con el middleware,
gestión de las complejidades de establecer aplicaciones distribuidas con
propiedades no funcionales apropiadas –como la seguridad– y el apoyo apropiado
de estrategias de implementación. Los middlewares basados en objetos
distribuidos están diseñados para proporcionar un modelo de programación
basado en principios orientados a objetos y, por tanto, para llevar los beneficios
del enfoque a objetos para la programación distribuida. Los principales ejemplos
de middleware basados en objetos distribuidos incluyen Java RMI y CORBA.
CORBA (Common Object Request Broker Architecture) es una herramienta
middleware que facilita el desarrollo de aplicaciones distribuidas en entornos
heterogéneos tanto en hardware como en software [Coulouris et al., 2012],
ejemplos de estos son:

 Distintos sistemas operativos (Unix, Windows, MacOS, OS/2).

 Distintos protocolos de comunicación (TCP/IP, IPX).
 Distintos lenguajes de programación (Java, C, C++).
 Distinto hardware.

El objetivo principal de CORBA es especificar un middleware para construir

aplicaciones del tipo cliente-servidor multi-nivel, distribuidas y centralizadas, y que
sean flexibles y extensibles.

Figura 3.13. Principales componentes de la arquitectura CORBA [Coulouris et al., 2001]

Sistemas basados en objetos distribuidos

Es aquel que está gestionado por un servidor y sus clientes invocan sus métodos
utilizando un "método de invocación remota". El cliente invoca el método mediante
un mensaje al servidor que gestiona el objeto, se ejecuta el método del objeto en
el servidor y el resultado se devuelve al cliente en otro mensaje.
Tecnologías orientadas a los objetos distribuidos:

1. RMI.- Remote Invocation Method (Sistema de Invocación Remota de Métodos):

Fue el primer fremework para crear sistemas distribuidos de Java. Este sistema
permite, a un objeto que se está ejecutando en una Máquina Virtual Java (VM),
llamar a métodos de otro objeto que está en otra VM diferente. Esta tecnología
está asociada al lenguaje de programación Java, es decir, que permite la
comunicación entre objetos creados en este lenguaje.

2. DCOM.- Distributed Component Object Model: El Modelo de Objeto

Componente Distribuido, esta incluido en los sistemas operativos de Microsoft. Es
un juego de conceptos e interfaces de programa, en el cual los objetos de
programa del cliente, pueden solicitar servicios objetos del programa servidores,
en otros ordenadores dentro de una red. Esta tecnología esta asociada a la
plataforma de productos Microsoft.

3. CORBA.- Common Object Request Broker Architecture: Tecnología introducida

por el Grupo de Administración de Objetos OMG, creada para establecer una
plataforma para la gestión de objetos remotos independiente del lenguaje de
programación.

Sistemas de archivos distribuidos

Sistemas NFS y AFS Son dos de los sistemas de archivos distribuidos más
difundidos son los sistemas AFS y NFS [Coulouris et al., 2001]. Las principales
características de estos sistemas son descritas a continuación.

Sistema NFS (Network File Systems)

El sistema de archivos NFS fue diseñado por la compañía Sun Microsystems en

1985, con el propósito de ejecutarse en una red local (LAN). Entre las
características de un sistema NFS se puede destacar lo siguiente:
Es el estándar para tener acceso a archivos distribuidos en UNIX.
Utiliza el modelo cliente - servidor y ambos se encuentran en el núcleo del sistema
operativo.
 Permite la heterogeneidad de arquitecturas.
 Permite las transparencias de acceso, localización, fallas y desempeño.
 Alcanza transparencia de localización.
 La transparencia de migración es implementada parcialmente.
 Las transparencias de replicación, concurrencia y escalabilidad no son
implementadas.
 NFS utiliza RPC. Es un servidor sin estados, por lo que no mantiene
abiertos los archivos ni guarda información sobre ellos.

Inconvenientes del NFS

Entre los inconvenientes que presenta NFS se pueden mencionar las siguientes:
 No es eficiente para sistemas distribuidos grandes.
 Las implementaciones caché inhiben a tener un pobre desempeño en
las operaciones de escritura.

Sistema AFS (Andrew File Systems)

Este sistema de archivos distribuido fue desarrollado en Carnegie Mellon
University (CMU) en 1986. El objetivo de AFS es compartir información a gran
escala (10,000 estaciones de trabajo). Al igual que en Network File Systems
(NFS), en AFS no hay que modificar programas de UNIX. La estrategia clave para
alcanzar escalabilidad en AFS es a través del manejo de caché de archivos
completos en los nodos clientes. El mecanismo de AFS considera lo siguiente
[Sánchez, 1995]:

1. Un proceso cliente realiza un operación “open” en un espacio compartido,

entonces el servidor envía una copia del archivo al cliente.
2. El cliente realiza todas las operaciones en la copia local.
3. Una vez que el archivo es cerrado, se envía la versión modificada al servidor,
mientras que el cliente mantiene la copia local.

Entre las principales características del sistema AFS, se pueden indicar las
siguientes [Coulouris et al., 2001]:

• Los cachés usados son del orden de 100 MB.

• El tamaño de los paquetes para la transferencia de archivos es de 64 KB. •
El uso de bases de datos no está considerado.
• Se usan directorios locales o compartidos para colocar los archivos.
• Está constituido principalmente por dos componentes de software a nivel
usuario (ver figura 8.3):
o Vice, en el servidor.
o Venus, en el cliente.
• Cuando muchos clientes usan el AFS, se puede comparar favorablemente
con respecto al NFS.
• Intercepta las llamadas a operaciones de archivos.
• Permite guardar información de estado sobre las copias de los archivos.
• Emplea réplicas de archivos, por lo que una nueva escritura deberá de ser
hecha en todas las copias distribuidas.
• Soporta seguridad, protección y heterogeneidad.
• Los usuarios pueden cambiar de máquinas y usar el mismo nombre. Este
proceso deberá ser transparente, excepto por algunas fallas de ejecución
iniciales que son necesarias al poner los archivos de usuarios en las
máquinas locales
Conclusión
Los sistemas distribuidos son sistemas débilmente acoplados, en donde cada uno
de sus nodos es una computadora completa con un conjunto completo de
periféricos y su propio sistema operativo.
A menudo, estos sistemas se esparcen sobre una gran área geográfica. Con
frecuencia se coloca middleware encima del sistema operativo para ofrecer un
nivel uniforme para que las aplicaciones interactúen con él. Los diversos tipos de
middleware son: middleware basado en documentos, basado en archivos, basado
en objetos y basado en coordinación. Algunos ejemplos son: World Wide Web,
CORBA, Linda y Jini.

Referencias

Clasificación de los sistemas. (3 de Octubre de 2012). Obtenido de

esbanhr.blogspot.com: http://esbanhr.blogspot.com/2012/10/clasificacion-
de-los-sistemas.html

HERRERO PEREZRUL, J. A. (20 de Junio de 2019). Sistemas operativos 2.

Obtenido de Google Sites:
https://sites.google.com/site/mrtripus/home/sistemas-operativos-2/1-2-
conceptos-y-
López Fuentes, F. d. (2015). Sistemas distribuidos. México: UNIVERSIDAD
AUTÓNOMA METROPOLITANA.

Martinez, E. (03 de Junio de 2019). Sistemas Operativos distribuidos. Obtenido de

Rincon del vago: https://html.rincondelvago.com/sistemas-operativos-
distribuidos.html

Objetos distribuidos. (03 de Junio de 2019). Obtenido de

sistemasdistribuidosetitc.weebly.com:
https://sistemasdistribuidosetitc.weebly.com/objetos-distribuidos.html

Sergiooney . (17 de Junio de 2012). Sistemas operativos distribuidos. Obtenido de

www.slideshare.net: https://www.slideshare.net/sergiooney/sistemas-
operativos-distribuidos-13355041