Post on 05-Dec-2015
1
INGENIERÍA EN
SISTEMAS COMPUTACIONALES
Materia: Programación De Base De Datos
Semestre - Grupo - Sistema: 6° Semestre – Semiescolarizado.
Producto Académico: Investigacion
Tema: U2.- Aplicaciones Con Arquitectura Cliente/Servidor.
Presenta: Alan De Jesús Díaz Enriquez, 106Z0085
Docente: I.S.C. Rafael Zamudio Reyes
H. ALVARADO, VER. AGO. – DIC. 2015
INSTITUTO TECNOLOGICO SUPERIOR
DE ALVARADO
2
INDICE
Introducción ................................................................................................................................................... 3
U2.- Aplicaciones Con Arquitectura Cliente/Servidor. ........................................................................ 4
2.1.- El Modelo Cliente Servidor ................................................................................................................ 4
2.2.- Ventajas Y Desventajas ...................................................................................................................... 6
Ventajas ........................................................................................................................................................... 6
Desventajas .................................................................................................................................................... 7
2.3.- Programación de un sistema con arquitectura Cliente/Servidor. ........................................... 8
Programación con sockets ........................................................................................................................ 9
2.4.- Arquitectura de 3 capas. .................................................................................................................. 10
Patrones de Arquitectura de Software .................................................................................................. 11
2.5.- Arquitectura de n capas. .................................................................................................................. 12
Aplicación n capas. .................................................................................................................................... 12
Conclusión .................................................................................................................................................... 13
Fuentes .......................................................................................................................................................... 14
3
Introducción
En el mundo de TCP/IP las comunicaciones entre computadoras se rigen básicamente por lo que
se llama modelo Cliente-Servidor, éste es un modelo que intenta proveer usabilidad, flexibilidad,
interoperabilidad y escalabilidad en las comunicaciones.
El término Cliente/Servidor fue usado por primera vez en 1980 para referirse a PC’s en red.
Este modelo Cliente/Servidor empezó a ser aceptado a finales de los 80’s. Su funcionamiento es
sencillo: se tiene una máquina cliente, que requiere un servicio de una máquina servidor, y éste
realiza la función para la que está programado (nótese que no tienen que tratarse de máquinas
diferentes; es decir, una computadora por sí sola puede ser ambos cliente y servidor dependiendo
del software de configuración).
4
U2.- Aplicaciones Con Arquitectura Cliente/Servidor.
En esta arquitectura la capacidad de proceso está repartida entre los clientes y los servidores,
aunque son más importantes las ventajas de tipo organizativo debidas a la centralización de la
gestión de la información y la separación de responsabilidades, lo que facilita y clarifica el diseño
del sistema.
La separación entre cliente y servidor es una separación de tipo lógico, donde el servidor no se
ejecuta necesariamente sobre una sola máquina ni es necesariamente un sólo programa. Los tipos
específicos de servidores incluyen los servidores web, los servidores de archivo, los servidores del
correo, etc. Mientras que sus propósitos varían de unos servicios a otros, la arquitectura básica
seguirá siendo la misma.
Una disposición muy común son los sistemas multicapa en los que el servidor se descompone en
diferentes programas que pueden ser ejecutados por diferentes computadoras aumentando así el
grado de distribución del sistema.
La red cliente-servidor es una red de comunicaciones en la cual los clientes están conectados a un
servidor, en el que se centralizan los diversos recursos y aplicaciones con que se cuenta; y que los
pone a disposición de los clientes cada vez que estos son solicitados. Esto significa que todas las
gestiones que se realizan se concentran en el servidor, de manera que en él se disponen los
requerimientos provenientes de los clientes que tienen prioridad, los archivos que son de uso público
y los que son de uso restringido, los archivos que son de sólo lectura y los que, por el contrario,
pueden ser modificados, etc. Este tipo de red puede utilizarse conjuntamente en caso de que se
esté utilizando en una red mixta.
2.1.- El Modelo Cliente Servidor TCP es un protocolo orientado a conexión. No hay relaciones maestro/esclavo. Las aplicaciones,
sin embargo, utilizan un modelo cliente/servidor en las comunicaciones.
Un servidor es una aplicación que ofrece un servicio a usuarios de Internet; un cliente es el que pide
ese servicio. Una aplicación consta de una parte de servidor y una de cliente, que se pueden
ejecutar en el mismo o en diferentes sistemas.
Los usuarios invocan la parte cliente de la aplicación, que construye una solicitud para ese servicio
y se la envía al servidor de la aplicación que usa TCP/IP como transporte.
El servidor es un programa que recibe una solicitud, realiza el servicio requerido y devuelve los
resultados en forma de una respuesta. Generalmente un servidor puede tratar múltiples peticiones
(múltiples clientes) al mismo tiempo.
Figura: El modelo de aplicación cliente/servidor
5
Algunos servidores esperan las solicitudes en puertos bien conocidos de modo que sus clientes
saben a qué zócalo IP deben dirigir sus peticiones. El cliente emplea un puerto arbitrario para
comunicarse. Los clientes que se quieren comunicar con un servidor que no usa un puerto bien
conocido tienen otro mecanismo para saber a qué puerto dirigirse. Este mecanismo podría usar un
servicio de registro como Portmap, que utiliza un puerto bien conocido.
El modelo cliente-servidor consiste básicamente en un cliente que realiza peticiones a otro
programa (el servidor) que le da respuesta.
La tecnología denominada Cliente -Servidor es utilizada por todas las aplicaciones de
Internet/Intranet. Un cliente funciona en su ordenador local, se comunica con el servidor remoto, y
pide a éste información. El servidor envía la información solicitada
Características:
Espera y recibe las respuestas del servidor.
Por lo general, puede conectarse a varios servidores a la vez.
Normalmente interactúa directamente con los usuarios finales mediante una interfaz gráfica de
usuario
Los sistemas Cliente-Servidor pueden ser de muchos tipos, dependiendo de las aplicaciones que
el servidor pone a disposición de los clientes. Entre otros, existen:
Servidores de Impresión, mediante el cual los usuarios comparten impresoras.
Servidores de Archivos, con el cual los clientes comparten discos duros.
Servidores de Bases de Datos, donde existe una única base de datos.
Servidores de Lotus Notes, que permite el trabajo simultáneo de distintos clientes con los
mismos datos o documentos.
6
2.2.- Ventajas Y Desventajas
Ventajas
Existencia de plataformas de hardware cada vez más baratas. Esta constituye a su vez una de las
más palpables ventajas de este esquema, la posibilidad de utilizar máquinas mucho más baratas
que las requeridas por una solución centralizada, basada en sistemas grandes (mainframes).
Además, se pueden utilizar componentes, tanto de hardware como de software, de varios
fabricantes, lo cual contribuye considerablemente a la reducción de costos y favorece la flexibilidad
en la implantación y actualización de soluciones.
Facilita la integración entre sistemas diferentes y comparte información, permitiendo por ejemplo
que las máquinas ya existentes puedan ser utilizadas pero utilizando interfaces más amigables
el usuario. De esta manera, se puede integrar PCs con sistemas medianos y grandes, sin
necesidad de que todos tengan que utilizar el mismo sistema operativo.
Al favorecer el uso de interfaces gráficas interactivas, los sistemas construidos bajo este
esquema tienen una mayor y más intuitiva con el usuario. En el uso de interfaces gráficas para
el usuario, presenta la ventaja, con respecto a uno centralizado, de que no siempre es necesario
transmitir información gráfica por la red pues esta puede residir en el cliente, lo cual permite
aprovechar mejor el ancho de banda de la red.
La estructura inherentemente modular facilita además la integración de nuevas tecnologías y el
crecimiento de la infraestructura computacional, favoreciendo así la escalabilidad de las
soluciones.
Contribuye además a proporcionar a los diferentes departamentos de una organización,
soluciones locales, pero permitiendo la integración de la información.
Centralización del control: los accesos, recursos y la integridad de los datos son controlados por
el servidor de forma que un programa cliente defectuoso o no autorizado no pueda dañar el
sistema. Esta centralización también facilita la tarea de poner al día datos u otros recursos (mejor
que en las redes P2P).
Escalabilidad: se puede aumentar la capacidad de clientes y servidores por separado. Cualquier
elemento puede ser aumentado (o mejorado) en cualquier momento, o se pueden añadir nuevos
nodos a la red (clientes y/o servidores).
Fácil mantenimiento: al estar distribuidas las funciones y responsabilidades entre varios
ordenadores independientes, es posible reemplazar, reparar, actualizar, o incluso trasladar un
servidor, mientras que sus clientes no se verán afectados por ese cambio (o se afectarán
mínimamente). Esta independencia de los cambios también se conoce como encapsulación.
Existen tecnologías, suficientemente desarrolladas, diseñadas para el paradigma de C/S que
aseguran la seguridad en las transacciones, la amigabilidad de la interfaz, y la facilidad de
empleo.
7
Desventajas
El mantenimiento de los sistemas es más difícil pues implica la interacción de diferentes partes
de hardware y de software, distribuidas por distintos proveedores, lo cual dificulta el diagnóstico
de fallas.
Cuenta con muy escasas herramientas para la administración y ajuste del desempeño de los
sistemas.
Es importante que los clientes y los servidores utilicen el mismo mecanismo (por ejemplo sockets
o RPC), lo cual implica que se deben tener mecanismos generales que existan en diferentes
plataformas.
Hay que tener estrategias para el manejo de errores y para mantener la consistencia de los datos.
El desempeño (performance), problemas de este estilo pueden presentarse por congestión en la
red, dificultad de tráfico de datos, etc.
La congestión del tráfico ha sido siempre un problema en el paradigma de C/S. Cuando una gran
cantidad de clientes envían peticiones simultáneas al mismo servidor, puede ser que cause
muchos problemas para éste (a mayor número de clientes, más problemas para el servidor). Al
contrario, en las redes P2P como cada nodo en la red hace también de servidor, cuantos más
nodos hay, mejor es el ancho de banda que se tiene.
El paradigma de C/S clásico no tiene la robustez de una red P2P. Cuando un servidor está caído,
las peticiones de los clientes no pueden ser satisfechas. En la mayor parte de redes P2P, los
recursos están generalmente distribuidos en varios nodos de la red. Aunque algunos salgan o
abandonen la descarga; otros pueden todavía acabar de descargar consiguiendo datos del resto
de los nodos en la red.
El software y el hardware de un servidor son generalmente muy determinantes. Un hardware
regular de un ordenador personal puede no poder servir a cierta cantidad de clientes.
Normalmente se necesita software y hardware específico, sobre todo en el lado del servidor, para
satisfacer el trabajo. Por supuesto, esto aumentará el coste.
El cliente no dispone de los recursos que puedan existir en el servidor. Por ejemplo, si
la aplicación es una Web, no podemos escribir en el disco duro del cliente o imprimir directamente
sobre las impresoras sin sacar antes la ventana previa de impresión de los navegadores.
8
2.3.- Programación de un sistema con arquitectura Cliente/Servidor.
Un socket es un mecanismo de comunicación entre dos o más procesos, gracias al cual es posible
enviar o recibir información. A efectos de programación un socket funciona como un descriptor de
ficheros de bajo nivel; comandos como read() y write() funcionan con sockets de la misma forma que
lo hacen con ficheros y tuberías.
El conjunto de servicios que ofrece un socket fue diseñado para facilitar una conexión entre
procesos, tanto si se ejecutan en una sola máquina, como si lo hacen en red. Los procesos se
intercambian información transmitiendo datos a través de mensajes que circulan entre un socket en
un proceso y otro socket en otro proceso. Para la comunicación entre máquinas se suelen utilizar
los protocolos TCP/IP, logrando así la independencia del hardware y de la arquitectura de red
mediante la cual se establece el enlace; siendo esto posible gracias a la estructura en forma de
capas que posee una red de ordenadores (véase ). Los sockets son conexiones que pertenecen a
la capa de transporte de la estructura OSI. Una aplicación con sockets debe especificar los puertos
de protocolo local y remoto y la dirección IP remota que utilizará, si usará TCP o UDP, y si iniciará
transferencia o esperará por una conexión (es decir, si funcionará como servidor o cliente).
Tipos de sockets
El mecanismo de sockets está diseñado de forma genérica; un socket por sí mismo no contiene
información suficiente para describir la comunicación entre procesos. Los sockets operan dentro de
dominios de comunicación, que determinan el formato de direcciones a utilizar y el protocolo de
comunicación. Además el dominio define si los dos procesos que se comunican se encuentran en
el mismo sistema o en sistemas diferentes y cómo pueden ser direccionados. De esta forma un
socket puede clasificarse según su dominio y según el tipo de conexión que realice.
En función del tipo de conexión se dispone de varios tipos de socket, que describen la forma en la
que se transfiere información a través de ese socket: sockets stream, sockets datagrama y sockets
raw.
Los sockets stream son un servicio orientado a conexión donde los datos se transfieren sin
encuadrarlos en registros o bloques. Para establecer una comunicación utilizando el
protocolo TCP.
Los sockets datagrama son un servicio de transporte si conexión que utilizan el protocolo
de transporte UDP. Cada vez que se envían datagramas es necesario enviar el descriptor
del socket local y la dirección del socket que deve recibir el datagrama. Por tanto, hay que
enviar datos adicionales cada vez que se realice una comunicación. Los datos se envían y
reciben en paquetes cuya entrega no está garantizada.
Los sockets raw dan acceso a la capa de software de red subyacente o a protocolos de más
bajo nivel. Se utilizan sobre todo para la depuración del código de los protocolos. Los sockets
raw proporcionan acceso alInternet Control Message Protocol, ICMP, y se utiliza para
comunicarse entre varias entidades IP.
Con respecto a la clasificación en función del dominio, bajo Unix existen dos dominios: uno para
comunicaciones internas al sistem (dominio UNIX) y el otro para comunicaciones entre sistemas
(dominio Internet). El dominio UNIX (AF_UNIX) permite una comunicación intrasistema entre
procesos que corren en el mismo microprocesador. Se permiten tanto los sockets stream como los
9
datagrama; no se permiten los sockets de tipo raw. El dominio Internet (AF_INET) soporta los
protocolos estándar de Internet TCP y UDP y se utiliza para comunicar procesos que corren en
distintos microprocesadores. Permite sockets stream, datagrama y raw.
Programación con sockets
Las llamadas al sistema más significativas son:
socket() crea un nuevo socket que puede ser utilizado para comunicación en red. Tiene tres
argumentos: o dominio o familia de direcciones a la que pertenece el socket (AF_UNIX, AD_INET),
o tipo de socket a crear (SOCK_STREAM, SOCK_DGRAM),
o protocolo (en general, toma el valor 0).
socketpair() es muy similar a socket() excepto en que se crean dos sockets conectados. bind() asigna un nombre a un socket que no lo tiene. Con bind() el servidor registra su
dirección en el sistema de manera que los mensajes recibidos con su dirección le sean
entregados. La llamada a bind() tiene como argumentos:
o descriptor de fichero del socket, obtenido con la llamada a socket(),
o nombre asignado al socket,
o longitud del nombre.
bind() sólo permite especificar una dirección local.
connect() es similar a bind(), pero se utiliza para especificar la dirección de conexión a una
máquina remota. read() y write() pueden ser utilizadas tanto por el servidor como por el cliente para enviar y
recibir mensajes. Los clientes utilizan write() para enviar peticiones, mientras que los
servidores la utilizan para enviar réplicas. Una llamada a write() requiere tres argumentos:
o descriptor del socket al cual enviar los datos,
o datos a enviar,
o longitud de los datos.
Los servidores utilizan read() para recibir las peticiones que realizan los clientes con la
llamada write(). Después de enviar su petición, el cliente utiliza read() para recibir la réplica. Para leer una conexión read()dispone de tres argumentos:
o descriptor del socket a utilizar,
o dirección de un búfer,
o longitud máxima de dicho búfer.
read() extrae los bytes de datos que llegan al socket y los copia en el búfer.
close(), se utiliza para eliminar un socket una vez que un cliente o un servidor finaliza su uso.
listen() y accept() permiten al servidor escuchar soliciturdes de servicio (también pueden utilizarse send() y recv()). listen() establece el socket como el punto final pasivo de una
10
conexión, no suspendiendo la ejecución del proceso; no pueden enviarse mensajes a través de este socket, pero sí pueden recibirse mensajes de entrada. Dispone de dos argumentos:
o descriptor de fichero asociado con el socket creado usando la llamada al sistema socket(),
o tamaño de la cola de solicitudes que esperan mientras el servidor está ocupado cumplimentando una solicitud de servicio.
connect(), con esta función el cliente solicita la conexión. El servidor, previamente, habrá creado el cliente con socket(), lo habrá etiquetado con bind(), y habrá establecido una cola de escucha usando listen(). Los argumentos que recibe son:
o descriptor de fichero de socket devuelto por la función socket(), o nombre del socket.
Después de un retorno con éxito desde accept(), esta estructura contendrá la dirección de protocolo del socket del clente. Este neuvo socket será utilizado para todas las comunicaciones con el cliente. Si no hay ninguna solicitud de conexión en espera, accept() se bloqueará hasta que se coloca en la cola una solicitud de un cliente.
2.4.- Arquitectura de 3 capas.
La arquitectura de software incluye los aspectos estáticos y dinámicos más significativos
del software que se desea crear. De acuerdo Robert Pressman, la arquitectura de software no es
otra cosa que “…una descripción de los subsistemas y los componentes de un sistema informático
y las relaciones entre ellos”. De igual manera, la arquitectura de software de tres niveles, incluye
todos estos aspectos, y además, brinda mejores opciones para proyectos informáticos de gran
alcance y complejidad.
La arquitectura de software a utilizar para desarrollar un producto software se define en la fase de
elaboración, para poder comprender mejor el sistema, organizar el desarrollo del mismo, fomentar
la reutilización, y hacer evolucionar el sistema.
11
Patrones de Arquitectura de Software Existen diversos patrones de arquitectura, que ya están definidos, para dar solución a problemas
específicos con la arquitectura. Entre los patrones más utilizados se encuentran:
Modelo Vista Controlador (MVC)
Arquitecturas en Capas
Arquitecturas Orientadas a Objetos
Arquitecturas Basadas en Componentes
Arquitecturas Orientadas a Servicios
Arquitectura por capas
Uno de los más utilizados por empresas desarrolladoras de software para crear productos
informáticos, es el patrón de arquitectura por capas. Los principales estilos de arquitecturas
estratificadas de las aplicaciones distribuidas contemporáneas son:
Arquitecturas de dos niveles
Arquitecturas de tres niveles
Arquitecturas de n niveles
La mayor ventaja de este patrón de arquitectura es que en el desarrollo se lleva a cabo en varios
niveles, o capas, y en el caso de que exista algún error o la necesidad de algún cambio obligatorio,
solo es necesario cambiar el nivel en cuestión, sin afectar el correcto funcionamiento del resto del
sistema.
Arquitectura de tres niveles
También conocida como arquitectura de tres capas, la arquitectura de tres capas, define cómo
organizar el modelo de diseño en capas, que pueden estar físicamente distribuidas, lo cual quiere
decir que los componentes de una capa sólo pueden hacer referencia a componentes en capas
inmediatamente inferiores.
Para enfrentarse a estos temas, la comunidad de software desarrolló la noción de una arquitectura
de tres niveles. La aplicación se divide en tres capas lógicas distintas, cada una de ellas con un
grupo de interfaces perfectamente definido. La primera capa se denomina capa de presentación y
normalmente consiste en una interfaz gráfica de usuario de algún tipo.
La capa intermedia, o capa de empresa, consiste en la aplicación o lógica de empresa, y la tercera
capa, la capa de datos, contiene los datos necesarios para la aplicación. La capa intermedia (lógica
de aplicación) es básicamente el código al que recurre la capa de presentación para recuperar los
datos deseados. La capa de presentación recibe entonces los datos y los formatea para su
presentación.
12
Capa de presentación
Es la que se encarga de que el sistema interactúe con el usuario y viceversa, muestra el sistema al
usuario, le presenta la información y obtiene la información del usuario en un mínimo de proceso.
En el mundo de la informática es conocida como interfaz gráfica y debe tener la característica de
ser amigable, o sea, entendible y fácil de usar para el usuario. Esta capa se comunica únicamente
con la capa intermedia o de negocio.
Capa de negocio
Es donde residen las funciones que se ejecutan, se reciben las peticiones del usuario, se procesa
la información y se envían las respuestas tras el proceso. Se denomina capa de negocio o capa de
lógica del negocio, porque es aquí donde se establecen todas las reglas que deben cumplirse. Esta
capa se comunica con la de presentación, para recibir las solicitudes y presentar los resultados, y
con la capa de acceso a datos, para solicitar al gestor de base de datos almacenar o recuperar
datos de él.
2.5.- Arquitectura de n capas.
En una aplicación distribuida en n-capas los diferentes procesos están distribuidos en diferentes
capas no sólo lógicas, sino también físicas. los procesos se ejecutan en diferentes equipos, que
pueden incluso residir en plataformas o sistemas operativos completamente distintos. cada equipo
posee una configuración distinta y está optimizado para realizar el papel que le ha sido asignado
dentro de la estructura de la aplicación, de modo que tanto los recursos como la eficiencia global
del sistema se optimicen.
Aplicación n capas. El surgimiento de la tecnología de componentes distribuidos es la clave de las arquitecturas de n-
capas. Estos sistemas de computación utilizan un número variable de componentes individuales
que se comunican entre ellos utilizando estándares predefinidos y frameworks de comunicación
como:
• corba: (common object request broker architecture) del object management group (omg).
• dna : (distributed network applications) de microsoft (incluye com/dcom y com+ además de mts,
msmq, etc.
• ejb : (enterprise java beans) de sun microsystems
• xml : (extensible markup language) del world wide web consortium (w3
• .net: de microsoft que incluye nuevos lenguajes como visual basic.net, c#.
13
Conclusión
Sistema distribuido entre múltiples procesadores donde hay clientes que solicitan servicios y
servidores que los proporcionan. Separa los servicios situando cada uno en su plataforma más
adecuada.
Desde el punto de vista funcional, se puede definir la computación Cliente/Servidor como una
arquitectura distribuida que permite a los usuarios finales obtener acceso a la información en forma
transparente aún en entornos multiplataforma.
En el modelo cliente servidor, el cliente envía un mensaje solicitando un determinado servicio a un
servidor (hace una petición), y este envía uno o varios mensajes con la respuesta (provee el
servicio).
14
Fuentes
E.V.A., UCI. Coferencia#5 Modelo Cliente-Servidor. Teleinformática II.
http://www.monografias.com/trabajos24/arquitectura-cliente-servidor/arquitectura-cliente-
servidor.shtml
http://cervantes1bachdyg.wikispaces.com/Arquitectura+cliente-servidor
http://www.cmg.jovenclub.cu/munic/cruz/redes/pages/arquitectura.htm
http://www2.rhernando.net/modules/tutorials/doc/redes/cliente.html
El Proceso Unificado de Software. Roger Pressman.
Arquitectura de software
Programación por capas
http://iutll-abdd.blogspot.mx/2012/05/arquitectura-de-n-capas.html