nfraestructura para Recuperación Automática ante Fallos de Sistemas de Software mediante ...

175 Pages·2012·12.07 MB·Spanish

Universidad de Buenos Aires
Facultad de Ingeniería

Infraestructura para Recuperación Automática ante
Fallos de Sistemas de Software mediante Modelos de
Control en Tiempo Real

Aplicación a Plataformas Java EE

Tesis de Grado de Ingeniería en Informática
Orientación Sistemas Distribuidos

Alumna: Guillermina Gabriela Galache
[email protected] - [email protected]
Directores: Dr. Rodrigo Castro, FCEyN/UBA (externo)
Ing. Osvaldo Clua, FI/UBA

Año 2012
Tesis de Ingeniería en Informática Guillermina G. Galache - 77060
Resumen
En la presente Tesis se desarrolla una plataforma de software para posibilitar la adaptación
automática y autónoma de Sistemas Informáticos ante una degradación en su calidad de servicio.
La metodología Self-Healing ofrece ventajas particulares cuando se aplican técnicas de control
a lazo cerrado. Primero se acepta la no idealidad del sistema y el débil conocimiento de la dinámica de
su entorno y sus usuarios. Luego, se agrega una capa de supervisión que detecta estados o tendencias
no deseables y reacciona controlando parámetros de operación en pos de mitigar la degradación del
servicio.
Un factor que limita su adopción en entornos industriales es la fuerte dependencia de cada
estrategia de control particular con la herramienta específica que lo implementa, dificultando la
convergencia hacia una plataforma estándar.
Para contrarrestar esta situación, desarrollamos una herramienta genérica para diseñar e
implementar distintas estrategias de control en un contexto flexible y modular. Sus tres funciones
centrales: monitoreo, control y actuación se logran mediante componentes independientes integrados
mediante una red de datos.
Los controladores se implementan en un entorno de modelado y simulación basado en el
formalismo DEVS (Discrete Event System Specification) que permite especificar de forma
matemáticamente robusta controladores de cualquier naturaleza: continuos, a tiempo discreto, a
eventos discretos, y/o combinaciones de ellos (híbridos).
Esto facilita el desarrollo de estrategias de control acorde al enfoque System-In-The-Loop
(sistema dentro del lazo): los modelos son desarrollados, ensayados y verificados mediante
simulaciones desacopladas del sistema real a controlar (“sistema fuera del lazo”); luego, cuando el
desempeño es aceptable, las entradas y salidas del controlador son simplemente “redireccionadas”
hacia el sistema real (“sistema dentro del lazo”) para su validación.
Mediante un proceso iterativo los modelos de simulación pasan a ser ejecutados en tiempo real
convirtiéndose directamente en el producto final.
Demostramos la eficacia de la plataforma diseñando un control sencillo tipo on-off para regular
el consumo de CPU y memoria de una aplicación Web sobre Java EE. Los ensayos expusieron
dinámicas inesperadas de la aplicación controlada, y la plataforma mostró flexibilidad para adaptar el
control incorporando los nuevos conocimientos adquiridos.
Esperamos que nuestro desarrollo contribuya a disminuir la brecha existente entre la Ingeniería
de Software y la Ingeniería de Control en el contexto del aseguramiento de la calidad de servicio de
aplicaciones industriales.

2
Tesis de Ingeniería en Informática Guillermina G. Galache - 77060
Agradecimiento

Quiero agradecerles a mis directores, Dr. Rodrigo Castro e Ing. Osvaldo Clua, por haberme
orientado en la realización del presente trabajo.
A Lic. Adriana Echeverria, Ing. Hugo Pagona y Lic. Alejandro Turri por haber aceptado ser
jurados del presente trabajo y por su buena predisposición para definir rápidamente la fecha de la
defensa.
A mi familia, en especial a mi mamá y a Martin, por haberme apoyado durante toda mi carrera
e hicieron posible que pudiera llevarla adelante.
A mis amigos y especialmente a Julia por haberme ayudado con la preparación de la defensa y
en los ensayos.
Por último, quiero dedicarle este trabajo a mi hija Micaela que es quien me inspira en todo lo
que hago, y es la personita más importante en mi vida.

3
Tesis de Ingeniería en Informática Guillermina G. Galache - 77060
Contenido
Capítulo 1: Introducción................................................................................................................ 8
1.1 - Contexto............................................................................................................................. 9
1.2 - Motivación ....................................................................................................................... 10
1.3 - Definición del Problema .................................................................................................. 11
1.4 - Objetivos .......................................................................................................................... 12
1.5 - Estructura del Informe ..................................................................................................... 12
Capítulo 2: Conceptos Preliminares ............................................................................................ 14
2.1 - JVM ................................................................................................................................. 15
2.1.1 - Componentes Principales de la JVM ....................................................................... 16
2.2 - Servidores de Aplicaciones JEE ...................................................................................... 18
2.3 - Confiabilidad y Sistemas Self-Healing ............................................................................ 21
2.3.1 - ¿Qué se entiende por confiabilidad de un sistema? ................................................. 21
2.3.1.1 - Las Amenazas a la Confiabilidad del Sistema.............................................. 22
2.3.1.2 - Formas de Lograr la Confiabilidad de un Sistema ....................................... 26
2.3.2 - Elementos de los Sistemas Self-Healing ................................................................. 28
2.3.2.1 - Fault Model o modelo de defectos ............................................................... 28
2.3.2.2 - System Response o respuesta del sistema ..................................................... 29
2.3.2.3 - System Completeness o completitud del sistema .......................................... 30
2.3.2.4 - Desgin Context o contexto de diseño ........................................................... 30
2.4 - Monitoreo y Actuación .................................................................................................... 31
2.4.1 - Técnicas de Monitoreo ............................................................................................. 33
Capítulo 3: Estado del Arte ......................................................................................................... 34
3.1 - Principales enfoques en sistemas Self-Healing ............................................................... 35
3.1.1 - Self-Healing basado en Modelos de Arquitecturas .................................................. 36
3.1.2 - Self-Healing basado en Ingeniería de Control ......................................................... 39
3.2 - Trabajos previos relevantes ............................................................................................. 43
3.2.1 - JVMMon .................................................................................................................. 43
3.2.2 - Aqua ......................................................................................................................... 45
3.2.3 - Arco Iris ................................................................................................................... 47
3.2.3.1 - Extensiones Realizadas a Rainbow .............................................................. 49
3.2.3.2 - Principio de Funcionamiento de Arco Iris .................................................... 50
3.2.3.3 - Elección de Estrategias Rainbow vs Arco Iris.............................................. 51
3.2.4 - Teoría de control aplicada a un servidor Web .......................................................... 51

4
Tesis de Ingeniería en Informática Guillermina G. Galache - 77060
3.2.4.1 - Arquitectura de Apache HTTP Server: Propiedades relevantes del
sistema a controlar ...................................................................................................... 51
3.2.4.2 - Entradas de Control y Salidas Controladas .................................................. 52
3.2.4.3 - Obtención del Modelo del Sistema a Controlar ........................................... 53
3.2.4.4 - Evaluación del Modelo del sistema .............................................................. 54
3.2.4.5 - Diseño del Modelo del Controlador ............................................................. 55
3.2.5 - Análisis preliminar ................................................................................................... 55
3.3 - Relevamiento de tecnologías de Monitoreo y Actuación para la JVM ........................... 56
3.3.1 - Técnicas de Monitoreo de la JVM ........................................................................... 56
3.3.2 - Java Platform Debugger Architecture (JPDA) ......................................................... 57
3.3.2.1 - Java Virtual Machine Tool Interface (JVMTI) ............................................. 58
3.3.3 - Java Management Extensions (JMX) ...................................................................... 59
3.3.3.1 - Managed Bean (MBean) .............................................................................. 60
3.3.3.2 - Platform MBeans .......................................................................................... 61
3.3.4 - Simple Network Management Protocol (SNMP) .................................................... 62
3.3.5 - Herramientas de Monitoreo de la JVM .................................................................... 63
3.3.6 - APIs de Administración y Monitoreo ...................................................................... 64
Capítulo 4: Solución Propuesta e Implementación ..................................................................... 65
4.1 - Servidor de aplicaciones - JBoss ..................................................................................... 67
4.1.1 - Arquitectura del JBoss AS ....................................................................................... 67
4.1.2 - JBoss web server ...................................................................................................... 68
4.2 - Monitor ............................................................................................................................ 69
4.2.1 - Nagios ...................................................................................................................... 69
4.2.1.1 - Arquitectura .................................................................................................. 69
4.2.1.2 - Plugins .......................................................................................................... 71
4.2.1.3 - Macros .......................................................................................................... 72
4.2.2 - Recolección de métricas .......................................................................................... 73
4.3 - Sensor y Actuador ............................................................................................................ 74
4.3.1 - BrainyPDM .............................................................................................................. 75
4.3.1.1 - Arquitectura .................................................................................................. 75
4.3.2 - Recepción de las métricas ........................................................................................ 77
4.3.3 - Modificaciones Realizadas a BrainyPDM ............................................................... 78
4.3.3.1 - Transmisión de las métricas al sistema de control externo .......................... 78
4.3.3.2 - Actuación ...................................................................................................... 82

5
Tesis de Ingeniería en Informática Guillermina G. Galache - 77060
4.4 - Control mediante Modelos en Tiempo Real .................................................................... 85
4.4.1 - Formalismo DEVS ................................................................................................... 86
4.4.2 - PowerDEVS ............................................................................................................. 88
4.4.2.1 - Arquitectura de PowerDEVS ....................................................................... 88
4.4.3 - Modificaciones realizadas a PowerDEVS ............................................................... 92
4.4.3.1 - Envío de datos al exterior ............................................................................. 92
4.4.3.2 - Recepción de datos del exterior.................................................................... 92
Capítulo 5: Prueba de Concepto ................................................................................................ 100
5.1 - Descripción del escenario .............................................................................................. 101
5.2 - Control ........................................................................................................................... 101
5.2.1 - Controlador ............................................................................................................ 102
5.3 - Esquema de la prueba de concepto ................................................................................ 104
5.3.1 - Nagios .................................................................................................................... 104
5.3.2 - BrainyPDM ............................................................................................................ 106
5.3.2.1 - Configuración de los MBeans .................................................................... 106
5.3.2.2 - Configuración de los transmisores ............................................................. 107
5.3.2.3 - Configuración de los actuadores ................................................................ 108
5.3.3 - PowerDEVS ........................................................................................................... 109
5.3.3.1 - Sensor ......................................................................................................... 110
5.3.3.2 - Procesador .................................................................................................. 110
5.3.3.3 - Efector ........................................................................................................ 112
5.4 - Casos de prueba ............................................................................................................. 113
5.4.1 - Caso de prueba 1 .................................................................................................... 113
5.4.1.1 - Caso de Test 0 (Línea de base) ................................................................... 114
5.4.1.2 - Caso de Test 1 ............................................................................................. 116
5.4.1.3 - Caso de Test 2 ............................................................................................. 118
5.4.2 - Caso de prueba 2 .................................................................................................... 120
5.4.2.1 - Caso de Test 0 (Línea de base) ................................................................... 121
5.4.2.2 - Caso de Test 1 ............................................................................................. 122
5.4.3 - Discusión de resultados ......................................................................................... 125
Capítulo 6: Conclusiones y Trabajo Futuro............................................................................... 126
6.1 - Conclusiones .................................................................................................................. 127
6.1.1 - Síntesis de aportes .................................................................................................. 128

6
Tesis de Ingeniería en Informática Guillermina G. Galache - 77060
6.1.2 - Producción científica ............................................................................................. 128
6.1.3 - Clasificación según la Taxonomía de Koopman ................................................... 129
6.2 - Trabajo Futuro ............................................................................................................... 130
Anexo A: Manual de instalación ............................................................................................... 131
A.1 - Compilación .................................................................................................................. 132
A.2 - Instalación ..................................................................................................................... 133
A.2.1 - Nagios ................................................................................................................... 133
A.2.2 - BrainyPDM ........................................................................................................... 133
A.2.3 - PowerDEVS .......................................................................................................... 135
A.2.4 - JBoss ..................................................................................................................... 135
Anexo B: Código Fuente de los Modelos DEVS ...................................................................... 136
B.1 - Sensor ............................................................................................................................ 137
B.2 - Procesador ..................................................................................................................... 137
B.3 - Efector ........................................................................................................................... 141
Anexo C: Artículo presentado en ASSE 2012 ........................................................................... 144
Glosario ..................................................................................................................................... 161
Referencias ................................................................................................................................ 165
Índice de Figuras ....................................................................................................................... 173
Índice de Listados...................................................................................................................... 175

7
Tesis de Ingeniería en Informática Guillermina G. Galache - 77060

Capítulo 1: Introducción

8
Tesis de Ingeniería en Informática Guillermina G. Galache - 77060
1.1 - Contexto
La importancia de las disciplinas de aseguramiento de la calidad de servicio y de la
confiabilidad de Sistemas Informáticos crece acorde a su incremento en complejidad y adopción
masiva. Al mismo tiempo, aumentan las dificultades para implementar exitosamente dichas disciplinas
dentro de las restricciones impuestas por el mercado en términos de tiempo y costos de desarrollo.
Surge entonces la necesidad de diseñar estrategias que le otorguen a los Sistemas Informáticos
capacidades para administrarse en forma autónoma y automática en fase de producción, partiendo
exclusivamente de especificaciones de objetivos de calidad definidos en la fase de diseño. Esto implica
que posean la capacidad de reaccionar ante fallas propias y/o cambios en su entorno de ejecución que
impliquen un desvío del objetivo de calidad estipulado, sin necesidad de intervención humana y de
forma transparente para el usuario.
Diversos esfuerzos realizados tanto en el ámbito académico como industrial han propuesto
distintos enfoques para obtener lo que se conoce como sistemas Self-Healing [Ghosh et al, 2007,
Koopman, 2003]. En el ámbito privado IBM es una de las empresas que más esfuerzos ha dedicado a
la investigación en el tema (cf. [Ganek & Corbi, 2003] y [Kephart & Chess, 2003]).
La consideración a priori, en fase de diseño, de todas las posibles condiciones de falla de un
sistema y el consecuente diseño de medidas explícitas para prevenirlas, presenta grandes dificultades
cuando los sistemas tienen una complejidad tan solo levemente mayor a casos triviales, haciendo a los
problemas intratables en la práctica (explosión de estados).
En cambio, el enfoque Self-Healing acepta la no idealidad del sistema y el débil
conocimiento previo del comportamiento dinámico de su entorno y de sus usuarios, para luego
agregarle una capa de supervisión que detecte anomalías o situaciones que puedan conducir al sistema
supervisado a un estado no deseable, y reaccione controlando parámetros de operación en pos de
contrarrestar el estado de falla. Esta estrategia es más eficiente en términos de escalabilidad ya que
depende en mucho menor medida (o en ninguna medida, dependiendo del caso) del tamaño del
sistema. De hecho, una determinada estrategia de control puede ser directamente reutilizable
aplicándola a distintos Sistemas de Software de escala muy variada, siempre y cuando compartan
aquellas propiedades de su arquitectura para las cuales fue diseñada la estrategia de control.
Existen diferentes enfoques para el desarrollo e investigación de sistemas Self-Healing. En
[Ghosh et al., 2007] los autores relevan y clasifican varios de dichos enfoques.
Uno de los más evolucionados y difundidos es el propuesto por los autores en [Garlan &
Schmerl, 2002]. Utiliza el modelo de arquitectura del sistema a controlar para evaluar la dinámica del
mismo durante su ejecución y tomar decisiones acerca de la necesidad o no de aplicar acciones de
adaptación. El modelo de arquitectura utilizado representa al sistema a través de un grafo equivalente
que consta de componentes del sistema, sus interconexiones (conectores) y sus propiedades relevantes.
Este modelo es conocido en la literatura como C&C (componentes y conectores).
Otro enfoque muy distinto es el basado en modelos matemáticos de ciertas dinámicas del
sistema y de lazos de realimentación aptos para la aplicación de la Ingeniería de Control (ver
[Patikirikorala et al., 2012] para un relevamiento sistemático y el libro de texto [Hellerstein et al.,

9
Tesis de Ingeniería en Informática Guillermina G. Galache - 77060
2004] de referencia obligada en el tema).
Se trata de un área joven, esencialmente interdisciplinaria, que aplica el vasto conocimiento
acumulado durante más de dos siglos de uso de modelos matemáticos para mecanismos de
autorregulación de sistemas físicos esta vez a controlar sistemas lógico-digitales (redes, sistemas de
cómputo). El objetivo de control suele ser el de mantener métricas de performance (delay, jitter,
throughput, consumo de recursos, tasa de violación de deadlines, etc.) dentro de ciertos rangos
aceptables usualmente especificados por medio de Requerimientos de Calidad.
Las acciones de control disparan eventos discretos que implican la regulación gradual de
recursos disponibles (pools, buffers, colas, slots, etc.) entre diferentes consumidores compitiendo por
los mismos (tareas de sistema operativo, paquetes de red, trabajos en batch, pedidos HTTP, etc.)
Usualmente en las disciplinas informáticas, controles de ese estilo suelen diseñarse usando
técnicas ad-hoc. Sin embargo, la teoría clásica de control ha sido reconocida como un camino
prometedor para explotar los conocimientos teóricos y metodológicos previos acumulados en dicha
disciplina [Arzen et al., 2006]. Basándose en teoría de control, la estabilidad y la respuesta transitoria
de los mecanismos de control pueden ser sistemáticamente analizadas en forma matemática, y los
controladores pueden ser diseñados siguiendo diferentes criterios de optimalidad y/o robustez.
Evidentemente, uno de los principales escollos a vencer es la carencia de primeros principios
fundamentales en los sistemas digitales, principios que la física provee claramente para sistemas
mecánicos, eléctricos, hidráulicos, etc.
Es notable que independientemente del enfoque que se trate, todo sistema Self-Healing puede
plantearse conceptualmente como 4 etapas centrales expresables en términos de Ingeniería de Control:
a) monitoreo, con el fin de la recolección de datos acerca de la ejecución del sistema y de su entorno;
b) traducción y cálculo del error, en donde los datos recolectados son adaptados y comparados con
los objetivos de calidad, calculando los desvíos o “errores”; c) control, dedicado al análisis y cálculo
de un curso de acción para contrarrestar los desvíos y d) actuación, para la ejecución de acciones de
control concretas sobre propiedades manipulables del sistema.
1.2 - Motivación
A pesar de la caracterización unificada aplicable a todo sistema de Self-Healing -mencionada
en la sección precedente-, y de tratarse siempre de enfoques basados fundamentalmente en modelos -
aunque de distinta naturaleza-, es notable la gran dispersión de herramientas que proliferan.
Si bien la variedad de modelos surgidos de distintos enfoques puede interpretarse como una
virtud para una disciplina incipiente y en crecimiento, la consecuente diversidad de herramientas
especializadas para experimentación y/o implementación de soluciones prácticas aparece, en la
realidad, como una traba en al menos tres sentidos:
1. Difícil reutilización de técnicas de monitoreo y actuación, usualmente implementadas
de modo ad-hoc para situaciones particulares.
2. Difícil convergencia hacia una plataforma robusta y de aceptación amplia que permita
permear la barrera de la investigación para transferirse como tecnología usable en la
industria de software.

10