El paradigma cliente-servidor
C on ten ido
C onceptos básicos
Tipo de servidores
Servidores secuenciales y concurrentes
Servidores orientados a conexión y sin
conexión
Servidores con/sin información de estado
Sesión:
interacción entre cliente y servidor
Ejemplo:
C liente-servidor con paso de mensajes
Desarrollo de aplicaciones cliente-
servidor
2
Servidores web
U n a defin ición simple …
“El software del servidor acepta peticiones de
servicio desde el software del cliente, calcula
el resultado y lo devuelve al cliente”
3
Participantes
Elementos de
computación:
Cliente
Servidor
Red de interconexión
1) Petición
Red de interconexión
2) Respuesta
Máquina
Máquina del
cliente
servidor
4
Ejemplo: HTTP
1) Petición:
[Link]
[Link]
2) Respuesta
Servidor
Cliente
1) Petición: 2) Respuesta:
GET /[Link] HTTP/1.1 HTTP/1.1 200 OK
Host: [Link] Date: Fri, 31 Dec 2003 [Link] GMT
User-Agent: nombre-cliente Content-Type: text/html
[Línea en blanco] Content-Length: 1221
<html>
<body>
<h1>Página [Link]</h1>
(Contenido) . . .
</body>
</html>
5
Acceso distribuido vs.
computación distribuida
La computación de tipo cliente-
servidor es acceso distribuido
no computación
distribuida !!!
6
Cliente-Servidor
Asigna roles diferentes a los procesos que comunican: cliente
y servidor
Servidor:
O frece un servicio
Elemento pasivo: espera la llegada de peticiones
Cliente:
Solicita el servicio
Elemento activo: invoca peticiones
Servid Cliente
or 1
Petición de
servicio
Proceso cliente
Cliente
..
Proceso
.
2 servidor
Servicio
7
Conceptos previos
El modelo cliente-servidor es una abstracción
eficiente para facilitar los servicios de red
La asignación de roles asimétricos simplifica la
sincronización
Implementación mediante:
Sockets
Llamada a procedimientos remotos (RPC )
Invocación de métodos remotos (RMI,
C O RBA, … ) .
Paradigma principalmente adecuado para
servicios centralizados
Ejemplos: servicios de Internet (HTTP,
8
FTP, D N S, … )
Tipos de servidores de aplicaciones
En función del número de peticiones que es capaz de
atender:
Secuencial: una petición
Concurrente: múltiples peticiones atendidas al mismo
tiempo
En función de si existe una conexión preestablecida con
el cliente
Servidores orientados a conexión
Servidores N O orientados a conexión
En función de si almacena o no el estado de la
comunicación
Servidores con estado
Servidores sin estado
9
Modelo de servidor secuencial
El servidor sirve las peticiones de forma
secuencial
Mientras está atendiendo a un cliente no
puede aceptar peticiones de más clientes
petición
Cliente servidor
respues
ta
10
Flujo de ejecución de u n servidor
secuencial
Inicio de servicio
Aceptar petición de
sesión
Procesar la
petición del
cliente
11
Servidor secuencial
Flujo de ejecución de u n servidor
secuencial
Inicio de servicio
O btener
Aceptar petición de el
sesión resultad
+
o
Devolver la
respuesta al
Procesar la cliente
petición del
cliente
Servidor
secuencial 12
Cliente-Servidor secuencial
Servid Cliente
or 1
Solicitud
while(){ de
aceptar_petici
Cliente conexión
on() Sesión
tratar_peticion() 2
}
de
servicio
Cliente
n
13
Cliente-Servidor secuencial
Servid Cliente
or 1
Solicitud de
while(){ conexión
aceptar_petici
on() Cliente
Sesión de servicio
tratar_peticion() 2
}
Cliente
n
14
Cliente-Servidor secuencial
Servid Cliente
or 1
Solicitud de
while(){ conexión
aceptar_petici
on() Cliente Sesión de servicio
tratar_peticion() 2
}
Cliente
n
15
Modelo de servidor concurrente
El servidor crea un hijo que atiende la petición y
envía la respuesta al cliente
Se pueden atender múltiples peticiones de
forma concurrente
petició
n servidor
Cliente
Crea un proceso
hijo
respues
ta Proceso
hijo
16
Flujo de ejecución de u n servidor
concurrente
Servidor
concurrente
Inicio de servicio
Aceptar
petición
de sesión
C rear Procesar la fi
thread petición del n
Trabajado cliente 1
C
r rear
1 Procesar la fi
thread petición del n
Trabajado cliente 2
r2
C rear Procesar la fi
thread petición del n
Trabajado cliente n
17
rn
Flujo de ejecución de u n servidor
concurrente
Servidor
concurrente O btener
Inicio de servicio el
resultado
+
Aceptar Devolver la
petición respuesta al
de sesión cliente
C rear Procesar la
fi
thread petición del n
Trabajado cliente 1
C
r rear
1 Procesar la fi
thread petición del n
Trabajado cliente 2
r2
C rear Procesar la fi
thread petición del n
Trabajado cliente n
18
rn
Cliente-Servidor concurrente
Servid Cliente
or 1
Solicitud
while() de
{ aceptar_pet conexión
icion() Cliente
pthread_create( 2
) Sesión
servic
}
de
io
Cliente
n
19
Cliente-Servidor concurrente
Servid Cliente
or 1
Solicitud
while() de
{ aceptar_peti conexión
cion() Cliente
pthread_create() 2
} Sesión
servic
de
io
Cliente
n
20
Cliente-Servidor concurrente
Servid Cliente
or 1
Solicitud
while() de
{ aceptar_petici conexión
on() Cliente
pthread_creat 2
e() Sesión
servic
}
de
io
Hilo
1 Cliente
n
21
Cliente-Servidor concurrente
Servid Cliente
or 1
Solicitud
while() de
{ aceptar_peti conexión
cion() Cliente
pthread_create 2
() Sesión
servic
}
de
io
Hilo
1 Cliente
n
22
Cliente-Servidor concurrente
Servid Cliente
or 1
Solicitud
while() de
{ aceptar_petici conexión
on() Cliente
pthread_creat 2
e() Sesión
servic
}
de
io
Hilo
1 Cliente
n
Hilo
2
23
Cliente-Servidor concurrente
Servid Cliente
or 1
Solicitud
while() de
{ aceptar_peti conexión
cion() Cliente
pthread_create 2
() Sesión
servic
}
de
io
Hilo
1 Cliente
n
Hilo
2
24
Cliente-Servidor concurrente
Servid Cliente
or 1
Solicitud
while() de
{ aceptar_petici conexión
on() Cliente
pthread_creat 2
e() Sesión
servic
}
de
io
Hilo
1 Cliente
n
Hilo
2
Hilo n
25
Cliente-Servidor concurrente
Servid Cliente
or 1
Solicitud
while() de
{ aceptar_peti conexión
cion() Cliente
pthread_create 2
() Sesión
servic
}
de
io
Hilo
1 Cliente
n
Hilo
2
Hilo n
26
Diseño de servidores concurrentes
mediante threads
Distintas arquitecturas de SW para construir servidores paralelos:
Un proceso distribuidor que acepta peticiones y las distribuye entre
un pool de procesos ligeros
Cada proceso ligero realiza las mismas tareas: aceptar peticiones,
procesarlas y devolver su resultado
Segmentación: cada trabajo se divide en una serie de fases, cada
una de ellas se procesa por un proceso ligero especializado
Trabajador
Distribuidor
Solicitudes
Solicitudes
Solicitudes
Núcleo Núcleo Núcleo
E/S E/S E/S
27
Servidores orientados a conexión
En un servicio orientado a conexión, el cliente
y el servidor establecen una conexión (que
puede ser lógica), posteriormente insertan o
extraen datos desde esa conexión, y
finalmente la liberan
El flujo de tráfico se representa mediante un
identificador de conexión
Los datos no incluyen información sobre
la conexión establecida
Direcciones origen y destino
Ejemplo: T C P
28
Servidores sin conexión
En un protocolo no orientado a conexión
los datos son intercambiados usando
paquetes independientes, auto-contenidos,
cada uno de los cuales necesita
explícitamente la información de conexión
N o existe acuerdo previo
Ejemplo: IP, U D P
29
Concepto de sesión
Sesión: Interacción entre cliente y servidor
C ada cliente entabla una sesión separada e
independiente con el servidor
El cliente conduce un diálogo con el servidor
hasta obtener el servicio deseado
El servidor ejecuta indefinidamente:
Bucle continuo para aceptar peticiones de las
sesiones de los clientes
Para cada cliente el servidor conduce una sesión de
servicio
30
Protocolo de servicio
Se necesita un protocolo para especificar las
reglas que deben observar el cliente y el
servidor durante una sesión de servicio
En cada sesión el diálogo sigue un patrón
especificado por el protocolo
Los protocolos de Internet están publicados en las
RFCs
D efinición del protocolo de servicio:
Localización del servicio
Secuencia de comunicación entre procesos
Representación en interpretación de los datos
31
Tipos de servidores
Servidores sin estado:
Cada mensaje de petición y respuesta es
independiente de las demás
Ejemplo: HTTP
Servidores con estado:
Debe mantener información de estado (por ej.
anteriores conexiones de clientes) para
proporcionar su servicio
Cada petición/respuesta puede depender de otras
anteriores
Ejemplo:Telnet
32
Información de estado
Información de estado global
El servidor mantiene información para todos los
clientes durante la vida del servidor
Ejemplo: servidor de tiempo
Información de estado de sesión
El servidor mantiene información específica para
cada sesión iniciada por los clientes
Ejemplo: FT P (File Transfer Protocol)
33
Arquitectura de S W
La arquitectura de SW de una aplicación
cliente-servidor consta de tres niveles:
Nivel de presentación: cliente y servidor precisan una
interfaz de usuario
Nivel de lógica de aplicación: en el lado del servidor necesita
procesarse la petición del cliente, calcular el resultado y
devolverlo al cliente. En el lado del cliente se necesita enviar
al servicio la petición del usuario y procesar el resultado (por
ejemplo, mostrarlo por pantalla)
Nivel de servicio: los servicios requeridos para dar
soporte a la aplicación son (1) en el servidor aquellos
que permiten procesar la petición y 2) el mecanismo
de IPC
34
Arquitectura de las aplicaciones
Interfaz de usuario
Lógica de presentación
Lógica de aplicación
Lógica de servicio
35
¿Donde se ejecutan las tareas?
En el software del cliente (lado del
cliente)
En el software del servidor (lado del
servidor)
36
Responsabilidades en el cliente
Cliente:
Genera un mensaje de petición de servicio
Se conecta al servidor (dirección IP y puerto) [Solo
orientado a conexión]
Envía el mensaje de petición de servicio
Espera por la respuesta
Procesa la respuesta: imprimir, almacenar, etc.
Desconexión [Solo orientado a conexión]
37
Responsabilidades en el servidor
Servidor:
1. Espera conexiones entrantes de los
clientes
Una conexión entrante es una petición de
servicio
2. Por cada conexión:
Genera un thread de servicio [Solo servidores
concurrentes]
El proceso principal:
Vuelve a esperar por nuevas conexiones entrantes
El thread de
servicio:
1. Procesa la petición
2. C alcula el
resultado 38
3. D evuelve la
respuesta al
Aplicaciones cliente-servidor usando colas
de mensajes
Modelo proceso ligero distribuidor:
Cada petición al proceso ligero distribuidor supone la
creación de un proceso ligero trabajador
El proceso ligero trabajador responde al proceso cliente
Procesa la petición
Envía la respuesta al servidor
Una vez finalizada la sesión con el cliente, el proceso ligero
se destruye
Modelo concurrente:
Los procesos distribuidor y trabajador ejecutan de forma
concurrente
Modelo secuencial:
Sólo un proceso distribuidor
39
Ejemplo: sumar dos números
Máquina A Máquina B
sumar(5,2)
cliente servidor
5+2
NÚCLEO Resultado = 7 NÚCLEO
RED
40
@Fuente: Jesús Carretero, Félix García, Pedro de Miguel y Fernando Pérez. Mc Graw Hill
Ejemplo: Definición de tipos
#define MAXSIZE 256
struct peticion {
int a; /* operando 1 */
int b; /* operando 2 */
char q_name[MAXSIZE]; /* nombre de la cola cliente
donde debe enviar la respuesta
el servidor */
};
41
Ejemplo: Proceso servidor secuencial
#include “mensaje.h”
#include <mqueue.h>
void main(void) {
mqd_t q_servidor; /* cola de mensajes del servidor */
mqd_t q_cliente; /* cola de mensajes del cliente */
struct peticion pet;
int res;
struct mq_attr attr;
attr.mq_maxmsg = 20;
attr.mq_msgsize = sizeof(struct peticion);
q_servidor = mq_open(“SERVIDOR_SUMA”, O_CREAT|O_READ, 0700, &attr);
while(1) {
mq_receive(q_servidor, &pet, sizeof(pet), 0);
res = pet.a + pet.b;
/* se responde al cliente abriendo previamente su cola */
q_cliente = mq_open(pet.q_name, O_WRONLY);
mq_send(q_cliente, &res, sizeof(int), 0);
mq_close(q_cliente);
}
}
42
Ejemplo: Proceso cliente
#include “mensaje.h”
#include <mqueue.h>
void main(void)
{ mqd_t q_servidor; /* cola de mensajes del proceso servidor */
mqd_t q_cliente; /* cola de mensajes para el proceso cliente */
struct peticion pet;
int res;
struct mq_attr attr;
attr.mq_maxmsg = 1;
attr.mq_msgsize = sizeof(int);
q_cliente = mq_open(“CLIENTE_UNO”, O_CREAT|O_RDONLY, 0700, &attr);
q_servidor = mq_open(“SERVIDOR_SUMA”, O_WRONLY);
/* se rellena la petición */
pet.a = 5; pet.b = 2; strcpy(pet.q_name,
“CLIENTE_UNO”);
mq_send(q_servidor, &pet, sizeof(struct petiticion), 0);
mq_receive(q_cliente, &res, sizeof(int), 0);
mq_close(q_servidor);
mq_close(q_cliente);
mq_unlink(“CLIENTE_UNO”);
} 43
Ejemplo II: Servidor concurrente
Máquina A
sumar(5,2)
cliente
Resultado = 7
Máquina B
servidor
NÚCLEO
RED
5+2
Máquina A
cliente NÚCLEO
NÚCLEO
44
Estructura de u n servidor multihread
Proceso Proceso
cliente cliente
Cola del Cola del
cliente petició cliente
n
petició
n
Proceso
servidor
respuest Cola del
a Servidor respuest
a
Creación
del thread
Creación
del thread
Thread que Thread que
sirve la sirve la
petición petición
45
Cliente-servidor con colas de mensajes
46
Servidor multithread con colas de mensajes
(I)
#include “mensaje.h”
#include <mqueue.h>
#include
<pthread.h>
#include <stdio.h>
/* mutex y variables condicionales para proteger la copia del mensaje*/
pthread_mutex_t mutex_mensaje;
int mensaje_no_copiado = TRUE; /* TRUE con valor a 1 */
pthread_cond_t cond_mensaje;
int main(void)
{
mqd_t q_servidor; /* cola del servidor */
struct peticion mess; /* mensaje a recibir */
struct mq_attr q_attr; /* atributos de la cola */
pthread_attr_t /* atributos de los threads */
t_attr;
attr.mq_maxmsg = 20;
attr.mq_msgsize = sizeof(struct peticion));
47
Servidor multithread con colas de mensajes
(II)
q_servidor = mq_open(“SERVIDOR”, O_CREAT|O_RDONLY,
0700, &attr);
if (q_servidor == -1) {
perror(”No se puede crear la cola de servidor”);
return 1;
}
pthread_mutex_init(&mutex_mensaje, NULL);
pthread_cond_init(&cond_mensaje, NULL);
pthread_attr_init(&attr);
/* atributos de los threads */
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
…..
48
Servidor multithread con colas de mensajes
(III)
while (TRUE) {
mq_receive(q_servidor, &mess, sizeof(struct mensaje), 0);
pthread_create(&thid, &attr, tratar_mensaje, &mess);
}
}
49
Servidor multithread con colas de mensajes
(IV)
while (TRUE) {
mq_receive(q_servidor, &mess, sizeof(struct mensaje), 0);
pthread_create(&thid, &attr, tratar_mensaje, &mess);
C ondición de
carrera
}
}
50
Servidor multithread con colas de mensajes
(V)
while (TRUE) {
mq_receive(q_servidor, &mess, sizeof(struct mensaje), 0);
pthread_create(&thid, &attr, tratar_mensaje, &mess);
Sección crítica
/* se espera a que el thread copie el mensaje */
pthread_mutex_lock(&mutex_mensaje);
while (mensaje_no_copiado)
pthread_cond_wait(&cond_mensaje, &mutex_mensaje);
mensaje_no_copiado = TRUE;
pthread_mutex_unlock(&mutex_mensaje);
} /* FIN while */
} /* Fin main */
51
Servidor multithread con colas de mensajes
(VI)
void tratar_mensaje(struct mensaje *mes){
struct peticion mensaje; /* mensaje local */
struct mqd_t q_cliente; /* cola del cliente */
int resultado; /* resultado de la operación */
/* el thread copia el mensaje a un mensaje local */
pthread_mutex_lock(&mutex_mensaje);
memcpy((char *) &mensaje, (char *)&mes, sizeof(struct
peticion));
/* ya se puede despertar al servidor*/
mensaje_no_copiado = FALSE; /* FALSE con
valor 0 */
pthread_cond_signal(&cond_mensaje);
pthread_mutex_unlock(&mutex_mensaje);
52
Servidor multithread con colas de mensajes
(VII)
/* ejecutar la petición del cliente y preparar respuesta */
resultado = mensaje_local.a + mensaje_local.b;
/* Se devuelve el resultado al cliente */
/* Para ello se envía el resultado a su cola */
q_cliente = mq_open(mensaje_local.nombre, O_WRONLY);
if (q_cliente == -1)
perror(”No se puede abrir la cola del cliente */
else {
mq_send(q_cliente, (char *) &resultado,
sizeof(int), 0); mq_close(q_cliente);
}
pthread_exit(0);
}
53
Proceso cliente
#include “mensaje.h”
#include <mqueue.h>
void main(void) {
mqd_t
q_servidor; /*
mqd_t q_cliente; /* cola de mensajes para el proceso cliente */
cola de mensajes
struct peticion pet;
del proceso
int res;
servidor */
struct mq_attr attr;
attr.mq_maxmsg = 1;
attr.mq_msgsize = sizeof(int);
q_cliente =
mq_open(“CLIENTE_UNO”,
O_CREAT|O_RDONLY, 0700,
&attr);
q_servidor =
mq_open(“SERVIDOR_SUMA”,
O_WRONLY);
/* se rellena la petición */
pet.a = 5; pet.b =
2;
strcpy(pet.q_name,
“CLIENTE_UNO”);
mq_send(q_servidor, &pet, sizeof(struct petiticion), 0);
mq_receive(q_cliente, &res, sizeof(int), 0); 54
mq_close(q_servidor);
mq_close(q_cliente);
mq_unlink(“CLIENTE_UNO”);
G u í a de desarrollo de aplicaciones
cliente-servidor con paso de mensajes
1. Identificar el cliente y el servidor
C liente: elemento activo, varios
Servidor: elemento pasivo
2. Protocolo del servicio
Identificar los tipos mensajes y la secuencia de
intercambios de mensajes (peticiones y
respuestas)
3. Elegir el tipo de servidor
UD P sin conexión
TCP :
Una conexión por sesión
Una conexión por petición
4. Identificar el formato de los mensajes
(representación de los datos)
Independencia (lenguaje, arquitectura,
implementación, … )
55
Protocolo HTTP
HyperText Transfer Protocol se usa en W W W para
transferir hipertexto (páginas HTML con
hiperenlaces)
Usa el puerto T C P 80 para aceptar conexiones entrantes
Se basa en el paradigma cliente-servidor
Servidor web Cliente web
Elementos solicitud:
solicitud - <mandato> <dirección documento> <versión HTTP
>
- cabecera opcional
- datos opcionales
respuesta Elementos respuesta:
- línea de estado con formato <protocolo><códigos
estado><descripción>
- información de cabecera
- documento.
56
Protocolo HTTP: respuesta
C ontenido de la respuesta:
<protocolo> <código>
<cabeceras>
<recurso>
donde protocolo es aquel que entiede el
servidor
HTTP/0.9
HTTP/1.0
HTTP/1.1
HTTP/1.2
donde código es un código de error:
200 O K
400 Error en el cliente
500 Error en el servidor
….. 57
E jem plo
Servidor web Cliente web
GET /[Link] HTTP/1.1
Host: [Link]
HTTP/1.1 200 OK solicitud User-Agent: nombre-cliente
Date: Fri, 31 Dec 2003 [Link] [Línea en blanco]
GMT
Content-Type:
text/html Content-
Length: 1221
<html> respuesta
<body>
<h1>Página principal
de tuHost
</h1> (Contenido) . . .
</body>
</html>
58
