Вы находитесь на странице: 1из 41

Version 20/12/17

Sistemas Distribuidos

Tolerancia a fallos

1
Contenidos
Introducción
Sistemas tolerantes a fallos
Replicación
● Optimista
● Vectores de versiones
● Pesimista
● Copia primaria
● Réplicas activas
● Métodos de votación (quourum)
Ejemplos
Sistemas Distribuidos - Tolerancia a fallos 2
Introducción
● La fiabilidad de un sistema es una medida de
conformidad con una especificación autorizada de su
comportamiento
– Un sistema es fiable si cumple sus especificaciones

● Una avería o defecto es una desviación del


comportamiento externo del sistema
– Resultado de errores internos

● Las causas mecánicas o algorítmicas de los errores se


denominan fallos
– Los fallos pueden ser de HW o SW

Sistemas Distribuidos - Tolerancia a fallos 3


Ejemplos de fallos
● Explosión del Ariane 5 en 1996
– Enviado por la ESA en junio de 1996 (fue su primer
viaje)
– Coste del desarrollo: 10 años y 7000 millones de dólares
– Explotó 40 segundos después del despegue a 3700
metros de altura.
– El fallo se debió a la pérdida total de la información de
altitud.
– Causa: error del diseño software
– El SW del sistema de referencia inercial realizó la
conversión de un valor real en coma flotante de 64 bits
a un valor entero de 16 bits. El número a almacenar era
mayor de 32767 (el mayor entero con signo de 16 bits)
y se produjo un fallo de conversión y una excepción.

Sistemas Distribuidos - Tolerancia a fallos 4


Ejemplos de fallos
● Fallo de misiles Patriot
– Misiles utilizados en la guerra del golfo en 1991
para interceptar los misiles iraquíes Scud
– Fallo en la interceptación debido a errores en el
cálculo del tiempo.
– El reloj interno del sistema proporciona décimas de
segundo que se expresan como un entero
– Este entero se convierte a un real de 24 bits con la
perdida de precisión correspondiente.
– Esta pérdida de precisión es la que provoca un fallo
en la interceptación

Sistemas Distribuidos - Tolerancia a fallos 5


Ejemplos de fallos
● Fallo en la sonda Viking enviada a Venus
● En lugar de escribir en Fortran:
DO 20 I = 1,100 #Bucle de 100 iteraciones sobre
etiqueta I
● Se escribió:
DO 20 I = 1.100
– Como los blancos no se tienen en cuenta por el
compilador, éste lo interpretó como:
DO20I = 1.100
– Es decir, la declaración de una variable (0201) con
valor 1.100 (D indica un identificador real)

Sistemas Distribuidos - Tolerancia a fallos 6


La polilla que voló dentro
de un ordenador... bug

Sistemas Distribuidos - Tolerancia a fallos 7


Tipos de fallos

Defecto
físico
Permanente
Diseño
incorrecto

HW Intermitente
Error Avería
inestable

Entorno
inestable Transitorio

Error del
operador

Sistemas Distribuidos - Tolerancia a fallos 8


Definición

Sistema tolerante a fallos

Sistema que posee la capacidad interna para
asegurar la ejecución correcta y continuada de
un sistema a pesar de la presencia de fallos HW
o SW

Objetivo: Conseguir que un sistema sea
altamente fiable


Tolerancia a fallos en sistemas distribuidos:

Objetivo: Ofrecer un servicio distribuido
tolerante a fallos

Esquema básico: replicación

Sistemas Distribuidos - Tolerancia a fallos 9


Replicación

Objetivos

Mejorar el rendimiento (caché)

Mejorar la disponibilidad
‒ Si p es la probabilidad de fallo de un servidor
‒ Con n servidores la probabilidad de fallo del sistema será pn

Tipos de replicación
‒ De datos
‒ De procesos

Problemas que introduce
‒ Consistencia

Requisitos
‒ Transparencia
‒ Consistencia
‒ Rendimiento
Sistemas Distribuidos - Tolerancia a fallos 10
Arquitectura básica de
replicación

C FE RM
RM
Gestores de
Réplicas

C FE RM

Front-end (FE): gestiona la replicación haciéndola transparente

Sistemas Distribuidos - Tolerancia a fallos 11


Métodos de replicación

Métodos pesimistas: métodos de replicación que
aseguran consistencia: en caso de fallos en la red
imponen limitaciones en el acceso a los datos
‒ Copia primaria
‒ Réplicas activas
‒ Esquemas de votación (quorum)

Estáticos

Dinámicos

Métodos optimistas: métodos que no aseguran una
consistencia estricta

No imponen limitaciones

Ejemplos: vectores de versiones, el sistema de ficheros
CODA

Sistemas Distribuidos - Tolerancia a fallos 12


Modelos de consistencia

Consistencia fuerte:

Utilizan esquemas de replicación pesimista

Mantienen una consistencia total dentro del grupo de
réplicas

Consistencia débil:

Utilizan esquemas de control de concurrencia optimistas

Permite actualizaciones locales sin ningún tipo de
restricciones

En algún momento se comprueba la consistencia de
cada réplica y aquellas modificaciones que hallan dado
lugar a inconsistencias tienen que anularse o corregirse

Válidas cuando hay pocos accesos concurrentes en
escritura

Sistemas Distribuidos - Tolerancia a fallos 13


Copia primaria

Para hacer frente a k fallos, se necesitan k+1 copias

Un nodo primario

k nodos de respaldo

Lecturas: se envían al primario

Escrituras: se envían al primario

El primario realiza la actualización y guarda el resultado

El primario actualiza el resto de copias

El primario responde al cliente

Cuando falla el primario un nodo secundario toma su
papel

Otras alternativas:

Las copias se actualizan en segundo plano
Sistemas Distribuidos - Tolerancia a fallos 14
Sincronización de réplicas

Sistemas Distribuidos - Tolerancia a fallos 15


Réplicas activas

Todos los nodos sirven peticiones

Mejor rendimiento en lecturas

En escrituras se utiliza un multicast atómico

Se asegura el orden de las escrituras

RM

C FE RM FE C

RM

Sistemas Distribuidos - Tolerancia a fallos 16


Método de votación
(quorum)

Se definen dos operaciones READ y WRITE

Hay un conjunto de N nodos, que sirven peticiones:


Un READ debe realizarse sobre R copias

Un WRITE debe realizarse sobre W copias

Cada réplica tiene un número de versión V

Debe cumplirse que:
– R+W>N
– W+W>N
– R, W ≤ N

Sistemas Distribuidos - Tolerancia a fallos 17


Ejemplos de quorums

Quorum no válido

Sistemas Distribuidos - Tolerancia a fallos 18


¿Cómo elegir W y R?

Se analizan dos factores:

Rendimiento: depende del % de lecturas y escrituras
y su coste
Coste total = Coste L* p * R + Coste E * (1-p) * W

Tolerancia a fallos: depende de la probabilidad con la
que ocurran los fallos
Probabilidad fallo =
Probabilidad de fallo L + Probabilidad de fallo E

Ejemplo:
• N=7
• Coste de W=2 veces el coste de R(K)
• Porcentaje de lecturas (p)=70%
• Probabilidad de fallo = 0.05
Sistemas Distribuidos - Tolerancia a fallos 19
Sistema Serie

● Sea Ri(t) ula fiabilidad del componente i


● El sistema falla cuando algún componente falla
● Si los fallos son independientes entonces:
N
R (t )  Ri (t )
i 1

– La fiabilidad del sistema es menor

Sistemas Distribuidos - Tolerancia a fallos 20


Sistema Paralelo

● El sistema falla cuando fallan todos los


componentes

N
R (t ) 1  Q (t )
i 1
i donde Qi (t ) 1  Ri (t )

Sistemas Distribuidos - Tolerancia a fallos 21


Fiabilidad de un sistema
k-out-of-n
● El sistema funciona cuando funcionan al menos
k de n

r=n
R( k , n)= ∑
r=k
( nr ) R (1−R )
r n−r
K-out-of-n

Sistemas Distribuidos - Tolerancia a fallos 22


Solución

R W Coste Probabilidad de Probabilidad Probabilidad de


fallo en R de fallo en W fallo

1 7 4,9 7,8125E-10 0,301662704 9,05E-02


2 6 5 1,04688E-07 0,044380542 1,33E-02
3 5 5,1 6,02734E-06 0,003757043 1,13E-03
4 4 5,2 0,000193578 0,000193578 1,94E-04

Sistemas Distribuidos - Tolerancia a fallos 23


Método de votación


READ:

Se lee de R réplicas, se queda con la copia con la
última versión

WRITE:

Hay que asegurarse que todas las réplicas se
comportan como una sola (seriabilidad)

Se realiza en primer lugar una operación READ para
determinar el número de versión actual.

Se calcula el nuevo número de versión.

Se inicia un 2PC para actualizar el valor y el número
de versión en W o más réplicas.

Sistemas Distribuidos - Tolerancia a fallos 24


Compromiso en dos fases
(two-phase-commit)

Two-Phase-Commit (2PC)

Denominamos coordinador al proceso que realiza la
operación
Coordinador:

multicast: ok to commit?
P0 P1 P2
recoger las respuestas O K to c o m m it

todos ok => send(commit)


G ra b a r e n
else => send(abort) á re a te m p o ra l

ok
Procesos:

ok to commit=> guardar ¡C o m m it! H a c e r lo s c a m b io s


p e rm a n e n te s
la petición en un área temporal y responder ok

commit => hacer los cambios permanentes

abort => borrar los datos temporales


Nota: El 2PC se estudiará en detalle en el tema de Transacciones
Sistemas Distribuidos - Tolerancia a fallos 25
Votación jerárquica
● El problema del método anterior es que W
aumenta con el número de réplicas
● Solución: quorum jerárquico
– Ej: número de réplicas = 5 x 5 = 25 (nodos hoja)

Sistemas Distribuidos - Tolerancia a fallos 26


Votación jerárquica
● Se realiza el quorum por niveles
– Ej: número de réplicas = 5 x 5 = 25 (nodos hoja)

R1 W1 R2 W2 RT WT
1 5 1 5 1 25
1 5 2 4 2 20
1 5 3 3 3 15
2 4 2 4 4 16
2 4 3 3 6 12
3 3 3 3 9 9

¿Cuál se elige?

Sistemas Distribuidos - Tolerancia a fallos 27


Métodos adaptativos
dinámicos

Los métodos anteriores (estáticos) no se adaptan a los
cambios que ocurren cuando hay fallos:

Ejemplo:

Dado un esquema de votación para 4 réplicas con R=2 y
W=3

Si se produce la siguiente partición


No se pueden producir escrituras

Sistemas Distribuidos - Tolerancia a fallos 28


Método de votación
dinámica

Cada dato d está soportado por N réplicas {d1..dn}

Cada dato di en el nodo i tiene un número de versión
VNi (inicialmente 0)

Se denomina actual NVA(d) = max{VNi}  i

Una réplica di es actual si VNi = NVA

Un grupo constituye una partición mayoritaria si
contiene una mayoría de copias actuales de d

Cada copia di tiene asociado un número entero
denominado cardinalidad de actualizaciones SCi =
número de nodos que participaron en la actualización

Sistemas Distribuidos - Tolerancia a fallos 29


Método de votación
dinámica

Inicialmente SCi = N

Cuando se actualiza di

SCi = nº de copias de d modificadas durante esta
actualización

Un nodo puede realizar una actualización si pertenece
a una partición mayoritaria

Sistemas Distribuidos - Tolerancia a fallos 30


Algoritmo de escritura
 i accesible solicita VNi y SCi
M = max{VNi} incluido él
I = {i tal que VNi = M}
N = max{SCi, i  I}
if I  N/2
then
el nodo no pertenece a una partición mayoritaria, se rechaza la
operación
else {
 nodos  I
Actualizar
VNi = M+1
SCi = |I|
}

Sistemas Distribuidos - Tolerancia a fallos 31


Ejemplo
● N= 5
● Inicialmente:

A B C D E
VN 9 9 9 9 9
SC 5 5 5 5 5
● Ocurre una partición:

A B C D E
VN 9 9 9 9 9
SC 5 5 5 5 5

Sistemas Distribuidos - Tolerancia a fallos 32


Ejemplo
● ¿Escritura en partición 2?
● M= max{9, 9} = 9
● I={D, E}
● N= 5 , I = 2  5/2  No se puede realizar
● ¿Escritura en partición 1?
● M= max{9, 9, 9} = 9
● I={A, B, C}
● N=5
● I = 3 > 5/2  Se puede actualizar

A B C D E
VN 10 10 10 9 9
SC 3 3 3 5 5

Sistemas Distribuidos - Tolerancia a fallos 33


Ejemplo
● Nueva partición
A B C D E
VN 10 10 10 9 9
SC 3 3 3 5 5

Partición 1 Partición 2 Partición 3

● ¿Escritura en partición 1?
● M=max{10,10} = 10
● I = {A, B}
● N= 3
● I = 2 > 3/2  Se puede actualizar

Sistemas Distribuidos - Tolerancia a fallos 34


Ejemplo

A B C D E
VN 11 11 10 9 9
SC 2 2 3 5 5

Partición 1 Partición 2 Partición 3

Sistemas Distribuidos - Tolerancia a fallos 35


Unión de un nodo a un
grupo

Cuando un nodo se une a un grupo tiene que
actualizar su estado:

M=max{VNi}
I = {j, tal que M = VNj}
N = max{SCk, k  I}
if I  N/2
then
no se puede unir
else {
Actualiza su estado
VNi = M+1
SCi = N+1
}

Sistemas Distribuidos - Tolerancia a fallos 36


Ejemplo
● Se une la partición 2 y 3

A B C D E
VN 11 11 10 9 9
SC 2 2 3 5 5

Partición 1 Partición 2

● ¿Escritura en partición 2?
● M= max{10, 9, 9} = 10

● I={C}

● N=3

● I = 1  3/2  se rechaza

Sistemas Distribuidos - Tolerancia a fallos 37


Ejemplo
● Se une la partición 1 y 2

A B C D E
VN 11 11 10 9 9
SC 2 2 3 5 5

Partición 1 Partición 2

● ¿Escritura en partición 1?
● M= max{11, 11, 10} = 11

● I={A,B}

● N=2

● I = 2 > 2/2  Se actualiza

Sistemas Distribuidos - Tolerancia a fallos 38


Ejemplo

A B C D E
VN 12 12 12 9 9
SC 3 3 3 5 5

Partición 1 Partición 2

Sistemas Distribuidos - Tolerancia a fallos 39


Nota
● Estas transparencias se basan en las
elaboradas por el grupo ARCOS de la
Universidad Carlos III de Madrid.

Sistemas Distribuidos - Tolerancia a fallos 40


Referencias
● G. Coulouris, Distributed Systems:
Concepts and Design, Addison Wesley
2012, Fifth edition
● Chapter 18 – Replication

Sistemas Distribuidos - Tolerancia a fallos 41