Embed Size (px)
Citation preview
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA, CIENCIAS FÍSICAS Y MATEMÁTICA
CARRERA DE INGENIERÍA INFORMÁTICA
PROYECTO DE MEJORAMIENTO DEL CENTRO DE GESTIÓN DE RIESGOS
PARA MONITOREO DE REDES, EN LA FACULTAD DE INGENIERIA
CIENCIAS FÍSICAS Y MATEMÁTICA.
TRABAJO DE GRADUACIÓN PREVIO A LA OBTENCIÓN DEL TÍTULO DE
INGENIERO EN INFORMÁTICA.
AUTOR:
EDISON SANTIAGO SUNTAXI CEVALLOS
TUTOR:
ING. FERNANDO VÁSQUEZ ITURRALDE
QUITO-ECUADOR
2015
ii
DEDICATORIA
A mi madre por su esfuerzo, dedicación y amor, por su ejemplo, por la fortaleza
inculcada cada día, por ser padre y madre, por todo lo que me ha enseñado a lo
largo de mi vida, por ser uno de los pilares fundamentales de mi existencia.
A mi padre que ha estado siempre al pendiente de mis pasos y que siempre ha
estado dispuesto a apoyarme en cuanto me he propuesto.
iii
AGRADECIMIENTO
A mis padres por darme la vida, por apoyarme en todos los aspectos, por
acompañarme a lo largo de este camino, por no dejarme caer, por el esfuerzo
hecho para que pueda culminar mi carrera, por los consejos constantes que me
han permitido cumplir una meta más.
A mis amigos que han estado a mi lado, gracias por sus palabras de aliento y
colaboración siempre que lo he necesitado.
A mi tutor por el tiempo, dedicación y ayuda otorgada para el desarrollo de mi
tesis.
iv
AUTORIZACIÓN DE AUTORÍA INTELECTUAL
v
CERTIFICACIÓN
vi
vii
viii
CONTENIDO
CONTRAPORTADA…………………………………………………………………….i
DEDICATORIA .................................................................................................... ii
AGRADECIMIENTO ........................................................................................... iii
AUTORIZACIÓN DE AUTORÍA INTELECTUAL ................................................. iv
CERTIFICACIÓN ................................................................................................. v
CONTENIDO .................................................................................................... viii
LISTA DE FIGURAS .......................................................................................... xii
LISTA DE TABLAS ........................................................................................... xiii
RESUMEN ........................................................................................................ xiv
ABSTRACT ........................................................................................................ xv
DELIMITACIÓN DEL PROYECTO ................................................................... xix
ALCANCE DEL PROYECTO ............................................................................ xix
CAPÍTULO I ........................................................................................................ 1
1. PRESENTACIÓN DEL PROBLEMA ............................................................ 1
1.1. Planteamiento del Problema .................................................................. 1
1.2. Formulación del Problema ........................................................................ 2
1.3. Objetivos ................................................................................................... 2
1.3.2. Objetivos Específicos............................................................................. 3
1.4. Justificación .............................................................................................. 4
CAPÍTULO II ....................................................................................................... 6
2. Really Awesome New Cisco config Differ (RANCID) ................................... 6
2.1. Generalidades ........................................................................................... 6
2.2. Características de Rancid ......................................................................... 7
ix
2.3. CVSWeb ................................................................................................... 8
2.4. Prestaciones y posibilidades de la Herramienta........................................ 9
CAPÍTULO III .................................................................................................... 11
3. RASPBERRY PI Y SERVIDOR DE VoIP ................................................... 11
3.1. Generalidades ......................................................................................... 11
3.2. Antecedentes .......................................................................................... 13
3.3. Análisis .................................................................................................... 15
3.4. Raspberry Pi ........................................................................................... 17
3.4.1. Prestaciones del Hardware Raspberry Pi ............................................ 18
3.5. Asterisk ................................................................................................... 19
3.5.1. Protocolos VoIP ................................................................................... 19
3.5.2. Prestaciones de una Central Telefónica Asterisk ................................ 22
CAPÍTULO IV .................................................................................................... 25
4. CACTI......................................................................................................... 25
4.1. Descripción General ................................................................................ 25
4.2. RRDTool ................................................................................................. 26
4.2.2. Características de Cacti ....................................................................... 27
4.2.2.1. Fuente de Datos ............................................................................... 27
4.2.2.2. Gráficos ............................................................................................ 28
4.2.2.3. Manejo de Usuarios .......................................................................... 28
4.2.2.4. Plantillas ........................................................................................... 28
4.3. Principios de Funcionamiento ................................................................. 29
4.3.1. Data Retrieval – Obtención de Datos .................................................. 29
4.3.2. Data Storage – Almacenamiento de Datos .......................................... 30
4.3.3. Data Presentation – Presentación de Datos ........................................ 30
x
4.4. Arquitectura de Cacti ............................................................................... 31
4.5. Ampliación de la funcionalidad de recopilación de datos ........................ 33
4.5.1. SNMP .................................................................................................. 33
4.5.1.1. Componentes SNMP ........................................................................ 35
4.5.1.2. Representación de la Información .................................................... 36
4.5.1.3. Comunidades ................................................................................... 38
4.5.1.4. Mensajes SNMP ............................................................................... 38
4.5.2. Scripts para Cacti ................................................................................ 39
CAPÍTULO V..................................................................................................... 41
5. DESARROLLO, INSTALACIÓN Y CONFIGURACIONES .......................... 41
5.1. Instalación y configuración de RANCID .................................................. 41
5.1.1. Configuración de RANCID ................................................................... 43
5.1.1.1. Archivo rancid router.db ................................................................... 46
5.1.1.2. Archivo Rancid .clogin.rc .................................................................. 46
5.1.2. CvsWeb ............................................................................................... 47
5.3. Configuración de la Raspberry Pi ............................................................ 52
5.3.1. Configuración del Sensor DS18B20 .................................................... 53
5.3.2. SNMP en Raspberry Pi ........................................................................ 56
5.3.3. Configuración del Driver L298N y Micromotor de dos pasos ............... 58
5.4. Instalación de Cacti ................................................................................. 63
5.4.1. Configuración para la recolección información de temperatura, .......... 66
5.4.2. Configuración para la recolección de datos del servidor Asterisk, ....... 68
5.5. Configuración para el envío de data al Raspberry Pi .............................. 72
CAPÍTULO VI .................................................................................................... 74
6. CONCLUSIONES Y RECOMENDACIONES ............................................. 74
xi
6.1. CONCLUSIONES ................................................................................... 74
6.2. RECOMENDACIONES ........................................................................... 75
GLOSARIO DE TERMINOS ............................................................................. 77
BIBLIOGRAFÍA ................................................................................................. 82
ANEXOS ........................................................................................................... 84
xii
LISTA DE FIGURAS
Figura 1 TME - Ethernet Thermometer ............................................................. 13
Figura 2 Raspberry Pi ....................................................................................... 18
Figura 3 Raspberry Pi GPIO ............................................................................. 19
Figura 4 Estructura de Protocolos de VoIP ....................................................... 22
Figura 5 Funcionamiento Cacti ......................................................................... 29
Figura 6 Arquitectura Cacti ............................................................................... 32
Figura 7 Proceso de Administración ................................................................. 34
Figura 8 Estructura general del MIB ................................................................. 37
Figura 9 Interfaz CVSWeb ................................................................................ 49
Figura 10 Correos de Notificación – RANCID ................................................... 49
Figura 11 Cambios en Estado de Dispositivo - RANCID .................................. 50
Figura 12 Sensor DS18B20 .............................................................................. 53
Figura 13 GPIO Disposición de Pines ............................................................... 54
Figura 14 Conexión Sensor - Raspberry Pi ...................................................... 55
Figura 15 Resultado del Sensor de Temperatura ............................................. 55
Figura 16 Diagrama de Conexión Raspberry Pi y L298N ................................. 59
Figura 17 Raspberry Pi- Sensor de Temperatura - Driver L298N ..................... 63
Figura 18 Cacti Método de Entrada - Temperatura ........................................... 67
Figura 19 Cacti Fuente de Datos - Temperatura............................................... 67
Figura 20 Cacti Plantilla de Gráfico - Temperatura ........................................... 68
Figura 21 Cacti Fuente de Datos - Asterisk ...................................................... 70
Figura 22 Cacti Plantilla de Datos ..................................................................... 71
Figura 23 Cacti Fuente de Datos - Asterisk ...................................................... 71
Figura 24 Cacti Plantilla de Gráficos - Asterisk ................................................. 72
xiii
LISTA DE TABLAS
Tabla 1 Umbrales sugeridos para los sensores de temperatura y humedad .... 16
xiv
RESUMEN
“PROYECTO DE MEJORAMIENTO DEL CENTRO DE GESTIÓN DE RIESGOS
PARA MONITOREO DE REDES, EN LA FACULTAD DE INGENIERÍA
CIENCIAS FÍSICAS Y MATEMÁTICA”
La Facultad de Ingeniería, Ciencias Físicas y Matemática desde el laboratorio
de cómputo se encarga de realizar el monitoreo de red en la facultad gracias a
al Centro de Gestión de Riesgos del que dispone. Sin embargo, no contaba con
una herramienta que presente con gráficas de forma esquematizada y clara los
resultados del monitoreo de la red, para esto se implementa Cacti, esta
herramienta permitirá visualizar de forma concisa los resultados obtenidos en la
monitorización y apoyándose en la herramienta Rancid permitirá gestionar los
cambios que se hayan realizado en los dispositivos más relevantes de la red.
Además se extiende la funcionalidad de Cacti monitorizando agentes externos
como un sensor de temperatura y el caso de una central telefónica VoIP. Así
como se implementa un sistema de reacción oportuna frente al sensor, con un
motor que simula el accionar de un sistema de ventilación.
DESCRIPTORES:
HERRAMIENTAS DE MONITOREO / CACTI / RANCID / RASPBERRY PI /
ASTERISK / SNMP
xv
ABSTRACT
"IMPROVEMENT PROJECT RISK MANAGEMENT CENTER FOR
MONITORING NETWORK IN THE FACULTAD DE INGENIERÍA EN CIENCIAS
FÍSICA Y MATEMÁTICA"
The Facultad de Ingeniería, Ciencias Física y Matemática from the computer lab
is responsible for performing network monitoring in college thanks to his Center
for Risk Management. However, the faculty did not have a tool that presents
schematically and clearly graphs of the results from monitoring network, for this
Cacti is implemented; this tool will display concisely the results of monitoring and
beside on the Rancid tool will allow us to manage the changes that have been
made on the most relevant network devices. Also, Cacti system functionality will
be extended by the monitoring of external agents as a temperature sensor and
the case of a VoIP telephone. And a opportune reaction system to temperature
sensor with a motor that simulates the action of a ventilation system is
implemented.
DESCRIPTORS:
MONITORING TOOLS / CACTI / Rancid / RASPBERRY PI / ASTERISK /
SNMP
xvi
xvii
xviii
INTRODUCCIÓN
Los administradores de red y las personas a cargo de la supervisión de enlaces
y dispositivos necesitan herramientas que les permitan tener un conocimiento
oportuno del estado de los mismos a fin de reaccionar de manera pronta ante
cualquier evento y además la oportunidad de tomar decisiones y planificar
medidas preventivas frente a cualquier incidente que pueda llegar a ocurrir.
Esto gracias a las prestaciones que brindan varias herramientas de monitoreo
de red, siendo una de estas Cacti. Con Cacti logramos conocer el estado
operativo de los host, routers, switches, entre otros. Gracias a la versatilidad
que RRDTool permite al momento de recolectar información, se pueden acoplar
pollers de obtención de datos tanto con el protocolo snmp como con scripts
personalizados.
Es importante que estas herramientas tengan la capacidad de adaptarse al
entorno en el que se implementen, para esto se consideran elementos externos
que pueden ser susceptibles de monitoreo y que sean comunes en redes LAN y
redes más complejas a fin de extender la funcionalidad de la herramienta Cacti.
Algunos de los aspectos importantes en cuanto a la administración y
supervisión de una red son tanto el control de temperatura ambiente de lugares
estratégicos que pueden ser data centers, salas de laboratorios, entre otros,
como también las prestaciones de servicios de VoIP cuyo uso se está
ampliando gracias al software de licencia libre disponible como Asterisk.
Resulta entonces beneficioso y preciso el contar con una herramienta como
Cacti, que mientras realiza el monitoreo de dispositivos tradicionales también
monitorice agentes externos como un sensor de temperatura y un servidor
VoIP, y que permita tomar medidas de reacción frente a los resultados
obtenidos en la monitorización.
xix
DELIMITACIÓN DEL PROYECTO
Para la visualización de reportes dentro de la herramienta Cacti, se considera la
cantidad de dispositivos que conforman la red y de los cuales será posible
obtener datos monitorizados. Así como los gráficos de la herramienta Cacti son
dependientes de la información que puede ser almacenada, también se
depende de la configuración y los permisos que se hayan concedido en los
equipos a ser monitorizados.
Así como también existe dependencia con ciertos protocolos que deben ser
configurados en cada uno de los equipos para habilitar el envío de la
información que Cacti requiere, sean estos routers, switchs o servidores en
general y que deben tener el visto bueno de los administradores.
ALCANCE DEL PROYECTO
Este proyecto está enfocado en mejorar el centro de gestión de riesgos
existente mediante el uso de una herramienta de generación de reportes
gráficos como es Cacti, los gráficos obtenidos serán de dispositivos que se han
configurado en el sistema de monitoreo, que constan en la base de datos que
usa RRDTool y que consideren primordiales los administradores de la red. Se
mostrará la forma que se pueden agregar dispositivos para su monitoreo
gracias a los scripts que están incluidos en Cacti, en caso de necesitarlos,
dentro de los manuales de usuario.
Se implementará además un sensor de temperatura remoto mediante
Raspberry Pi y un sensor térmico externo; y se habilitará la observación de un
reporte gráfico en Cacti. Mientras que usando el protocolo de gestión SNMP se
logrará la interacción entre la data entregada por el sensor y un agente externo,
que en este caso será un motor y que simulará el accionar de un sistema de
ventilación.
xx
Se implementará un servidor de VoIP para realizar pruebas y se realizarán los
scripts y configuraciones necesarias para lograr obtener reportes de número y
tiempo de llamadas dentro de Cacti.
También se configurará la herramienta Rancid para poder almacenar backups
de las configuraciones de los dispositivos necesarios por el administrador de la
red.
1
CAPÍTULO I
1. PRESENTACIÓN DEL PROBLEMA
1.1. Planteamiento del Problema
En todas las empresas donde se manejan sistemas informáticos, es necesario
tener una monitorización de la infraestructura tecnológica en uso para
garantizar un buen servicio hacia los usuarios. Si esta se realiza en tiempo real
el administrador tendrá una gran ventaja para actuar en el momento que algún
incidente ocurra dentro de su organización.
Existen varias herramientas que permiten la monitorización de redes de
cualquier organización dependiendo su complejidad, muchas de ellas de
licencia libre. La herramienta Cacti es una de ellas, y permite crear graficas
sobre varias características de cada uno de los dispositivos de nuestra red.
Mediante el desarrollo de scripts y plugins podemos adaptarlo a las
necesidades que pueda tener el administrador y que no se encuentren
integradas en cacti, como por ejemplo, enviando información de sensores o
incluso de servidores de VoIP.
Existe un uso general del protocolo SNMP en la gestión de redes, en el que los
comandos de lectura para la obtención de información sobre nuestros
dispositivos son los más utilizados, sin embargo existen comandos de escritura
que pueden resultar sumamente beneficiosos a la hora de tomar medidas de
acción mientras se realiza la monitorización de estos dispositivos.
El control de nuestros dispositivos y la configuración de ellos es otro punto
importante dentro de la administración y gestión de nuestra red, hacer copias de
respaldo de estas configuraciones resulta crucial cuando existen dispositivos
altamente importantes por su servicio a nuestra red y que podrían sufrir
cambios que desestabilicen el rendimiento, Rancid es una herramienta de
2
código abierto que nos permite hacer control de cambios de configuración en
nuestros dispositivos, almacenamiento de configuraciones y restauración de
configuraciones.
Bajo esta perspectiva, resulta imperante la implementación de Rancid para el
control de cambios de configuraciones en nuestros dispositivos. Así como la
implementación de Cacti para mejorar y facilitar el monitoreo de parte de los
administradores, demostrando de paso la versatilidad que tiene esta
herramienta de adaptarse a la variedad de equipos que pueden existir en la red.
1.2. Formulación del Problema
¿Qué tan importante es contar con herramientas versátiles de generación de
gráficas y de control para monitorizar, gestionar y administrar nuestros
dispositivos en la red y que haciendo uso de protocolos de gestión como snmp
nos permita tomar acciones de respuesta con toda esta información
recolectada?
Aun cuando se cuenta con estadísticos y reportes de las actividades en nuestra
red, contar con una herramienta grafica como Cacti facilita al administrador
encontrar información relevante recolectada, por ejemplo, le facilita encontrar
los picos de uso de red respecto al tiempo, o hallar novedades con dispositivos
de una manera fácil debido al estilo gráfico de notificaciones. De igual forma
tener una herramienta como Rancid ayuda a restaurar cualquier cambio no
deseado en la configuración de estos dispositivos.
1.3. Objetivos
1.3.1. Objetivo General
3
Implementar Cacti en una red que usa RRDTool como recolector de datos, para
la obtención de gráficos que ayuden en el monitoreo de dispositivos y gestión
de la red e implementar Rancid para la gestión de copias de respaldo de
configuraciones de los dispositivos.
1.3.2. Objetivos Específicos
Entre los objetivos específicos se encuentran:
Realizar la instalación de Cacti y la configuración adecuada para su
funcionamiento en el ambiente propuesto.
Configurar e implementar un sensor de temperatura usando Raspberry Pi
y un sensor externo, usaremos el modelo DS18B20, de manera que sea
posible la captura de la temperatura exterior.
Desarrollar un script que recolecte y almacene la información de
temperatura que provee el sensor en nuestra Raspberry Pi de forma que
pueda ser almacenada por RRDTool.
Desarrollar un script y configurar una OID privada de manera que nuestra
Raspberry Pi usando el protocolo snmp sea capaz de transmitir la
información de la temperatura y se logre obtener la visualización de la
temperatura de forma gráfica en nuestro servidor.
4
Implementar y configurar un servidor de VoIP, usaremos la distribución
Asterisk de licencia libre, para realizar la integración en las tareas de
monitorización que realiza Cacti.
Implementar un script que recolecte y almacene la información sobre el
estado de Asterisk, siendo las principales el número de llamadas y la
duración de estas. Obtener la información en el formato requerido de
manera que se logre visualizar el estado de Asterisk mediante Cacti.
Realizar la instalación de Rancid y la configuración adecuada para
gestionar las copias de respaldo de los dispositivos más relevantes de la
red.
Desarrollar los scripts necesarios para que nuestra Raspberry Pi sea
capaz de activar un elemento externo simulando una acción frente a la
información monitorizada, en este caso un motor de dos pasos.
1.4. Justificación
Hoy en día la mayoría de empresas requiere de herramientas que faciliten el
trabajo de gestión de tal manera que el tiempo de reacción ante cualquier
eventualidad se vea disminuido, gráficos como los que brinda Cacti permiten al
administrador hallar de manera eficaz incidentes y novedades; a la vez que
herramientas como Rancid facilitan la gestión de copias de respaldo para las
configuraciones de nuestros dispositivos, de forma que el administrador pueda
entrar de lleno en la administración y gestión de la red.
5
Rancid es una herramienta de licencia libre que permite hacer una gestión de
los cambios en las configuraciones de nuestros equipos almacenándolos en un
repositorio y permitiendo el acceso a estos siempre que sean necesarios. Algo
que resulta oportuno teniendo en cuenta el constante crecimiento de las redes
al que tienden las empresas y los continuos cambios en las configuraciones en
nuestros routers y switchs. Además que debido a la incorporación de nuevos
dispositivos se requiere una mayor atención en la gestión de las subredes,
puertos, filtros, entre otros aspectos.
Cacti es una herramienta de licencia GPL que permite su libre utilización en
cualquier entorno, posee una interfaz bastante intuitiva que facilita su uso y que
resulta eficaz en redes del tamaño de una LAN, así como también para redes
más amplias con muchos dispositivos.
Cacti funciona bajo un ambiente conocido como LAMP, que lo conforman
PHP+Apache+MySQL y a la que se puede acceder desde cualquier navegador,
permite el uso de varias plantillas para la visualización de gráficos y además
permite la construcción de plantillas personales a medida en caso de no
encontrarse alguna adecuada para la comodidad de los usuarios.
El uso de RRDTool para el almacenamiento de datos y generación de gráficos
convierte a Cacti en una herramienta ideal para la monitorización de estos
dispositivos dada la naturaleza de series temporales que caracteriza sus
gráficos. Y que además por considerar el almacenamiento en intervalos
constantes de tiempo optimiza el espacio que se utiliza en nuestro servidor.
La posibilidad de crear scripts propios, ya sean en php, python, perl, bash, etc.,
para obtener información relevante de ser monitorizada, permite extender la
funcionalidad de Cacti al momento de generar gráficos, hasta convertirla en una
herramienta sólida y completa de gestión y monitoreo.
6
CAPÍTULO II
2. Really Awesome New Cisco config Differ (RANCID)
2.1. Generalidades
Los administradores de red actualmente utilizan herramientas como Really
Awesome New Cisco config Differ (RANCID) para realizar un seguimiento de
qué partes de una configuración de red están cambiado.1 Cada vez que se
realiza un cambio en la configuración en ejecución de un dispositivo, RANCID
guarda automáticamente la configuración antigua en un sistema de control de
versiones y el administrador de la red ofrece una breve explicación de por qué
se hizo el cambio.
Esta herramienta realiza una diferenciación basada en líneas entre el archivo
almacenado y el nuevo, este es generado por una secuencia de comandos de
edición y luego RANCID envía por correo electrónico este script de resultado
junto con una explicación proporcionada por la persona que realizó el cambio a
todos los otros administradores de esa red. Dependiendo la necesidad de los
administradores las notificaciones pueden ser configuradas incluso para
enviarse a teléfonos móviles vía mensaje de texto, pero ya que se usa el
servidor de correo instalado en el equipo y considerando el limitante de
caracteres existentes junto a la extensión en el uso de dispositivos con internet
móvil, hacen del envío de mails con el resumen total de los cambios realizados
la mejor opción al configurar el archivo con a lista de contactos.
Como la mayoría de las herramientas basadas en UNIX, la configuración de
RANCID se realiza mediante la edición de un conjunto de archivos de
configuración en el sistema huésped; la ejecución de RANCID se inicia desde la
línea de comandos del sistema o de forma automática programada a través del
1 http://www.shrubbery.net/rancid/
7
demonio cron de Unix; los repositorios de información generados por RANCID a
su vez se pueden acceder desde cualquier herramienta de navegación CVS o
Subversion.
2.2. Características de Rancid
RANCID es un script en Perl que utiliza scripts de inicio de sesión (clogin) para
acceder a un dispositivo, ejecutar comandos para mostrar la configuración, para
recolectar dicha información de configuración, etc., luego filtra la salida y le da
un formato adecuado al estándar CSV y por seguridad omite cualquier
información confidencial, como contraseñas o usuarios.
Usamos RANCID para tomar la copia de seguridad de configuraciones de
Routers como CISCO, 3COM, JUNIPER entre otros, ya que son las marcas
más populares utilizadas por las compañías en la actualidad y la hemos
utilizado también porque se cuenta con equipos de estas marcas dentro de la
Facultad de Ingeniería.
Rancid se puede ejecutar de manera manual mediante el comando rancid-run.
Este comando buscará todos los dispositivos listados en un archivo llamado
router.db ubicado en el directorio de instalación y traerá las configuraciones
para cada dispositivo. La información de acceso para cada dispositivo se
almacena en el archivo .cloginrc en la carpeta de inicio del administrador. Una
vez se han extraído las configuraciones, podemos ejecutar el comando rancid-
cvs para actualizar el archivo CVS.
El proceso descrito anteriormente con brevedad para realizar copias de
seguridad utilizando Rancid, puede ser programado para funcionar
automáticamente a una frecuencia semanal, mensual, dependiendo la
necesidad del administrador de la red. Luego los archivos de configuración de
cada dispositivo descargados pueden ser revisados mediante cualquier
8
navegador accediendo a la URL http://ip-servidor/cgi-bin/cvsweb disponibles
para su manipulación.
RANCID hace este proceso de una manera simple y que podríamos ordenar
como sigue:
Hace login en cada uno de los dispositivos en la tabla de rutas (router.db)
Ejecuta varios comandos para obtener la información que se guardará
Prepara la información de salida; le da formato y elimina datos oscilantes
o incrementales
Envía un correo electrónico sobre cualquier diferencias de la colección
anterior a una lista de correos
Y finalmente confirma esos cambios en el sistema de control de
revisiones.
2.3. CVSWeb
CVSweb es una interfaz WWW basado en CVS, siglas de "Concurrent Version
System". CVS trabaja comparando dos versiones de un mismo archivo para
encontrar todas las diferencias entre estos2. Los archivos se almacenan en una
carpeta del repositorio central en el servidor en donde ya se encuentra CVS
instalado de manera que se pueden comparar fácilmente. Esto hace que sea
una buena opción de uso al realizar copias de seguridad automáticas de
enrutadores y switches dentro de una red, al ver cómo se puede comparar
directamente dos versiones de archivos para encontrar los cambios entre una
versión antigua y otra nueva.
En la parte final de seguimiento de los cambios realizados en el archivo,
también guarda versiones anteriores del archivo de configuración para
garantizar potenciales copias de seguridad a ser restaurados en caso de ser
necesario. CVSweb añade una interfaz para un sitio web, el listado de archivos
2 http://cvshome.org/eng/vorteile.html
9
guardados que se toma desde el repositorio central para que puedan abrirse y
ver los cambios ocurridos.
Esto se logra a través del CGI (Common Gateway Interface) que es una interfaz
entre el cliente Web y el servidor Web que se ejecuta a manera de programa
pero mediante el corridos de scripts. CGI es bastante viejo y ha sido
reemplazado en gran parte por los diferentes lenguajes de programación como
PHP, Pearl, etc., sin embargo, todavía se puede encontrar en los ambientes de
Linux, usado por administradores como una herramienta rápida para la
supervisión y administración del sistema a través del navegador web.
2.4. Prestaciones y posibilidades de la Herramienta.
Actualmente se utilizan productos como ChangeGear3 o Remedy4 para
administrar los cambios efectuados en una red. Estos productos manejan un
sistema de tickets para documentar los cambios, lo que dificulta encontrar un
mecanismo para comparar el contenido de los archivos de configuración o
permitir una medida en cómo se ha cambiado la red.
Existen varios papers en el estudio de redes que definen grupos y supergrupos
de dispositivos y los cambios correlacionados a través de las configuraciones
de las redes. Se están realizando algoritmos para tratar de observar la
evolución de las redes de área local virtuales para ayudar a sus diseños y
refactorizaciones.
El número de líneas en que difieren múltiples versiones de un archivo de
configuración de una red, no es la mejor elección para realizar una medición de
variación. Basándose en los cambios que sufre la red a través del tiempo, sin
embargo, resulta necesario el uso de más herramientas para cuantificar los
3 http://www.bmc.com/solutions/itsm/it-service-management.html 4 http://www.sunviewsoftware.com/
10
cambios en torno a la estructura jerárquica y para tratar de predecir la tendencia
en los cambios.
Varios investigadores han propuesto varias métricas en los archivos de
configuración de routers. En el paper Networked Systems Design and
Implementation (NSDI) 2009, Benson et al. presentan modelos complejos y
métricas para describir la complejidad de manera que se logra abstraer detalles
del lenguaje de configuración y para los cuales podrían resultar útiles los
archivos que almacena RANCID.
RANCID por si solo reporta cambios que en su estado normal contienen ruido
para este tipo de análisis. Por ejemplo, si se permuta 5 líneas en el archivo de
configuración, RANCID entonces reportará esas 5 líneas borradas y 5 líneas
agregadas aun si no se han realizado cambios reales en la configuración del
dispositivo.
Sin embargo el hecho de contar con esta herramienta ayuda al administrador a
llevar un control ordenado y detallado de las configuraciones de sus dispositivos
y brinda la posibilidad de tomar decisiones preventivas y de planificación con la
expectativa del desarrollo de algoritmos de gestión y análisis como se ha
expuesto en los párrafos anteriores.
11
CAPÍTULO III
3. RASPBERRY PI Y SERVIDOR DE VoIP
3.1. Generalidades
Un factor importante sobre el cual la mayoría de administradores desea tener
control es la temperatura ambiente en sus data centers, laboratorios, aulas con
varios computadores donde además pueden trabajar diferentes equipos
sensibles como routers, switchs, firewalls para asegurarse que las condiciones
son optimas y con esto un buen funcionamiento de la red, incluso en el hecho
de poder prevenir picos que podrían llevar a incidentes aún mayores.
Para monitorear el entorno de un data center las técnicas más comunes que se
utilizan hoy en día datan de aquellos tiempos en se tenían servidores
centralizados, que incluyen prácticas como caminar por la habitación con
termómetros y confiar en que el personal de administración sienta cómo está el
ambiente en la habitación. Pero a medida que los data center evolucionan, y el
procesamiento de los servidores y las tecnologías en los nuevos equipos elevan
la demanda de energía y generan mayor cantidad de calor, se debe analizar el
entorno más cuidadosamente.
Aunque es común que en equipos físicos como sistemas UPS, unidades de aire
acondicionado en las salas de cómputos, etc. se implementen funciones de
monitoreo y alerta sofisticadas, otros aspectos del entorno físico suelen pasarse
por alto. El monitoreo de los equipos no es suficiente: el entorno debe
considerarse de manera global y controlarse en forma proactiva para detectar
amenazas e intrusiones. Entre estas amenazas se incluyen las temperaturas
elevadas de entrada de los servidores.
Las instalaciones de redes remotas, por ejemplo entre facultades, data centers
o despachos particulares aumentan la necesidad de monitorizar de una forma
12
automática, dado que resulta poco práctica y poco confiable la presencia física
de personas para controlar aspectos como la temperatura o la humedad. Con la
introducción de dispositivos de red remotos sin supervisión, los administradores
de red deben contar con sistemas confiables para saber qué sucede.
Por otra parte, en los últimos años ha venido incrementando el uso de software
libre para servidores de voz sobre IP como solución en cuanto a
comunicaciones se refiere, por lo que contar con una herramienta que permita
hacer un seguimiento de las llamadas que se están realizando, la duración,
entre otros aspectos del servidor resulta sumamente relevante para el
administrador.
La voz sobre IP es un grupo de normas, dispositivos y protocolos, que logran
que la voz sea enviada de forma digital a través del internet, por lo que forman
una compleja tecnología que necesita ser monitoreada tanto a nivel de
hardware como de software para de esta manera poder garantizar el correcto
funcionamiento y la prevención o corrección de fallas.
Las implicaciones tecnológicas, así como las económicas, necesarias para
garantizar el funcionamiento de servicios y recursos son muy importantes, en
las cuales resaltan el acceso a internet en el caso de llamadas salientes y el
costo en dispositivos si se decide no utilizar softphones. No dejando de lado las
implicaciones de seguridad ya que se espera que un sistema de información
preserve la información que gestiona: efectividad, eficiencia, confidencialidad,
integridad, disponibilidad, cumplimiento y confiabilidad5, estas tecnologías
requieren un permanente y adecuado monitoreo por parte del administrador.
Esto hace necesario contar con una herramienta que genere reportes gráficos
de un servidor de voz sobre IP para ayudar en la administración a los gestores
de la red en el control sobre el número de llamadas, tiempos de duración, entre
otros.
5 http://www.voip-info.org/wiki/view/Asterisk+monitoring
13
3.2. Antecedentes
Se tienen en el mercado varias opciones para satisfacer las necesidades de
monitoreo. En cuanto a la temperatura se refiere existen varias soluciones
prácticas en el mercado, como por ejemplo el sensor térmico “TME - Ethernet
Thermometer” que nos presenta la empresa Papouch en su sitio web6. La
empresa AVTech también dispone de un sensor térmico con características
similares a las requeridas en nuestro caso, a un costo más elevado según se
aprecia en su sitio web.7
Figura 1 TME - Ethernet Thermometer
Estas opciones hacen uso de hardware y software para obtener la temperatura
y poder transmitirla por medio de la red en diferentes formatos legibles por
sistemas de gestión populares. Se basan en protocolos como SNMP para este
6 http://www.papouch.com/en/shop/product/tme-ip-ethernet-thermometer/?gclid=CjwKEAjwz_-nBRC0zbDb_YOT1TgSJACW2VECqVrggVN9cVhGPvvCdraHifB-hK5TYW-xgiNcWVVmmxoCEwbw_wcB 7 http://www.tempager.com/Products/Environment_Monitors/Room_Alert_3_Wi-Fi.htm
14
propósito, con lo que se tiene una guía para el desarrollo de un dispositivo
capaz de trabajar de manera similar, pero usando herramientas de licencia libre.
Se considera entonces el uso de un ordenador de placa reducida como es
Raspberry Pi que incorpora un módulo GPIO y que en conjunto con el uso de
un sensor de temperatura como el sensor ds18b20 puede determinar la
temperatura ambiente, como se desea, pero permitiendo una posible extensión
en la funcionalidad y uso del mismo.
De manera que podemos obtener el mismo resultado pero usando software y
hardware de licencia libre con la ventaja que conllevan la reducción de costos y
de obtener el control completo sobre nuestro equipo para personalizaciones que
puedan necesitar.
Varias empresas ofrecen software para brindar servicios de telefonía IP de
manera privada, entre las cuales se encuentran Cisco con su Call Manager,
Avaya con MultiVantage, Alcatel, Mitel, etc. Estas compañías normalmente
trabajan con estándares y protocolos propietarios, lo que dificulta su interacción
con soluciones de otros fabricantes. O incluso obtener información y acceso a
su código en caso de requerir alguna personalización en su funcionamiento.
En lo que a soluciones que utilicen protocolos abiertos, existen algunas
opciones, entre las cuales destacan PBX4Linux, YATE, OpenPBX, FreeSwitch y
Asterisk, siendo esta la predominante. Desarrollada por la empresa Digium,
Asterisk implementa todas las funcionalidades de una centralita telefónica
(PBX) usando estándares abiertos.8 Amplios proyectos de Telefonía IP con
Asterisk se han desarrollado, y varios de ellos involucran la implementación de
teléfonos IP remotos. Por lo que la interacción entre Asterisk y una herramienta
de generación de gráficos de red como Cacti es posible una vez se tenga clara
la información que se quiere recolectar.
8 http://www.digium.com/en/solutions/ip-phone-systems/voip-basics
15
3.3. Análisis
Los sensores generalmente brindan datos en bruto, de manera que lo
realmente relevante es poder interpretar estos datos para poder generar alertas
y notificaciones que den el paso a la realización de las respectivas
correcciones. A medida que las estrategias de monitoreo se vuelven más
sofisticadas y los sensores proliferan por el centro de datos, es crucial que se
realice un procesamiento inteligente de la gran cantidad de datos que pudieran
surgir. Con el uso de una herramienta de generación de gráficos y gestión, se
logra una manera efectiva y eficiente de recolectar y analizar los datos de los
sensores para dar lugar a las acciones apropiadas; mediante el uso de
dispositivos recolectores que interpretan los datos de los sensores y envían
alertas para generar acciones de respuesta.
Para cada sensor, se deben determinar condiciones de funcionamiento
aceptables y se deben configurar umbrales para generar alarmas cuando las
mediciones excedan esas condiciones operativas. En condiciones ideales, el
sistema de monitoreo debería ser lo suficientemente flexible para configurar
múltiples umbrales por sensor para alertar en los niveles de información, de
advertencia, de alarma y de falla. Además de los umbrales de un solo valor,
deben existir condiciones de activación como los valores mayores que el umbral
durante un tiempo especificado, la tasa de aumento y la tasa de disminución.
En el caso de la temperatura, la alerta sobre el rango de cambio indica más
rápidamente la existencia de fallas que una imagen del valor de temperatura.
Los umbrales deben establecerse cuidadosamente para garantizar una utilidad
óptima. Pueden existir distintos umbrales que generen alertas diferentes según
la gravedad del incidente. Por ejemplo, un incidente del umbral de humedad
puede generar un correo electrónico al administrador de sistemas, mientras que
un sensor de humo puede generar una llamada automática al departamento de
16
bomberos. Del mismo modo, distintos niveles de umbrales garantizan diferentes
vías de escalamiento.9
Los umbrales deben configurarse globalmente a valores predeterminados y
luego ajustarse en forma individual según las especificaciones de los equipos
informáticos y la ubicación de montaje de los sensores con respecto a la
ubicación de los equipos (por ejemplo, un sensor ubicado cerca del suministro
de energía de un servidor debería brindar una alerta a un valor mayor que un
sensor ubicado cerca de una entrada de aire de un servidor). La Tabla 4 brinda
una lista de umbrales predeterminados sugeridos para la temperatura y la
humedad según la norma ASHRAE TC9.9.10 Además de estos umbrales, es
importante monitorear el rango de cambio de la temperatura. Un cambio de
temperatura de 5,6 °C (10 °F) en un período de 5 minutos es un probable
indicador de fallas en la unidad CRAC.
Sensor Umbral Superior Umbral Inferior
Temperatura del
Aire
25 °C (77 °F ) 20 °C (68 °F)
Humedad 55% de humedad
relativa
40% de humedad
relativa
Tabla 1 Umbrales sugeridos para los sensores de temperatura y humedad11
Al ser herramientas open source se pueden encontrar en la web varios
manuales desarrollados por comunidades acerca de su instalación y
configuración, además se tiene documentación agregada por parte de los
desarrolladores de las herramientas en sus respectivas páginas de internet por
lo que su implementación cuenta con el soporte requerido.
9 http://tc99.ashraetcs.org/documents.html 10 http://tc99.ashraetcs.org/documents.html 11 ASHRAE TC9.9 – Recomendación para ambientes de clase 1, que son aquellos controlados con mayor rigurosidad y serían los más adecuados para centros de datos con operaciones de misión crítica.
17
3.4. Raspberry Pi
Es una placa computadora de bajo costo desarrollada en la universidad de
Cambridge del Reino Unido por la Fundación Raspberry pi, esta fue creada con
el objetivo de estimular la enseñanza de ciencias de la computación cuando
Eben Upton, Rob Mullins, Jack Lang y Alan Mycroft, miembros de la facultad de
la universidad, descubrieron que los nuevos alumnos de informática estaban
poco preparados para una educación de alta tecnología.12
El diseño incluye un chip Broadcom BCM2835, que contiene un procesador
central (CPU) ARM1176JZF-S a 700 MHz, un procesador gráfico (GPU)
VideoCore IV, y 512 MB de memoria RAM. El diseño no incluye un disco duro o
una unidad de estado sólido, ya que usa una tarjeta SD para el almacenamiento
permanente; tampoco incluye fuente de alimentación o carcasa.13
En cuanto a su software, existen varias distribuciones basadas en el sistema
operativo Linux, sin embargo la versión más estable y recomendada para su
uso es la llamada Raspbian. Raspbian es el sistema operativo basado en
Debian para trabajar en nuestra Raspberry pi, la misma que cuenta con
herramientas de desarrollo como IDLE para el lenguaje de
programación Python o Scracth, que resultan sumamente utiles al momento de
realizar pequeños programas.
12 https://www.raspberrypi.org/blog/ 13 http://en.wikipedia.org/wiki/Raspberry_Pi
18
Figura 2 Raspberry Pi
3.4.1. Prestaciones del Hardware Raspberry Pi
Algo que hace de Raspberry pi una gran opción al momento de realizar
proyectos es su GPIO, que son pines genéricos de entrada o salida que se
pueden controlar gracias a programas desarrollados en cualquier lenguaje
soportado por nuestra Raspberry Pi. GPIO tiene la estructura que muestra la
Figura 3.
19
Figura 3 Raspberry Pi GPIO
Estos pines se pueden programar para que operen de determinada manera de
acuerdo a nuestras necesidades. Por ejemplo para que permitan la entrada de
datos, como en el caso de sensores o incluso señales desde otro computador;
en cuanto a la salida se pueden programar en casos tan simples como
encender un led hasta casos en los que se requiere enviar data a otro
dispositivo. Por ejemplo, se pueden programar para que actúen como pines de
entrada o salida simulando palabras de nivel lógico de hasta 17 bits.
3.5. Asterisk
3.5.1. Protocolos VoIP
La telefonía IP, es una tecnología emergente en el mundo de las
Telecomunicaciones, y básicamente consiste en brindar los mismos servicios
que la telefonía tradicional, pero usando como base la pila de protocolos
TCP/IP. Esto proporciona una gran ventaja, al darle mayor uso a la
20
infraestructura ya establecida de datos en un área local, pero también grandes
retos cuando se quiera implementar este servicio en Internet, pues no se cuenta
con calidad garantizada.
Los Protocolos que son usados para llevar las señales de voz sobre la red IP
son comúnmente referidos como protocolos de Voz sobre IP o protocolos VoIP.
El tráfico de Voz sobre IP puede circular por cualquier red IP, incluyendo
aquellas conectadas a Internet, como por ejemplo redes de área local (LAN).
Existen una gran cantidad de protocolos que proponen formas distintas de
establecer y controlar comunicaciones voz sobre redes IP. A continuación se
enlistan los principales protocolos de VoIP14:
H.323 - Protocolo definido por la Unión internacional de Telecomunicaciones
(ITU-T).
Protocolo de Inicio de Sesiones (SIP) - Protocolo definido por el Grupo
Especial 12 sobre Ingeniería de Internet (IETF).
Megaco (También conocido como H.248) - Protocolos de control que define
el mecanismo necesario de llamada para permitir a un controlador Media
Gateway el control de puertas de enlace para soporte de llamadas de voz/fax
entre redes RTC-IP o IP-IP.
MiNet - Protocolo propiedad de Mitel.
CorNet-IP - Protocolo propiedad de Siemens.
14 http://www.idris.com.ar/pdf/ART0002%20-%20Protocolos%20en%20VoIP.pdf
21
Protocolo de intercambio entre Asterisk (IAX) - Protocolo original para la
comunicación entre PBXs Asterisk (Es un estándar para los demás sistemas de
comunicaciones de datos, actualmente está en su versión 2 - IAX2)
Skinny - Protocolo propietario peer-to-peer (igual a igual) utilizado en la
aplicación Skype.
IAX2 - Protocolo para la comunicación entre PBXs Asterisk en reemplazo
de IAX.
Jingle - Protocolo abierto utilizado en tecnología Jabber .
Protocolo de control de puerta de enlace de medios MGCP - Protocolo
propietario de Cisco.
weSIP - Protocolo licencia gratuita de Voz Telecom definido por el Grupo
Especial sobre Ingeniería de Internet (IETF).
Todos estos protocolos llegan a conformar la arquitectura que utiliza Asterisk
como se muestra en la siguiente figura:
22
Figura 4 Estructura de Protocolos de VoIP15
3.5.2. Prestaciones de una Central Telefónica Asterisk
Asterisk es un software PBX que utiliza los conceptos de software libre (GPL).
Digium, empresa que promueve Asterisk, invierte en ambos aspectos, el
desenvolvimiento de código fuente y en hardware de telefonía de bajo costo
que funciona con Asterisk. Además corre en plataforma Linux y otras
plataformas Unix con o sin hardware conectado a la red pública de telefonía,
PSTN (Red telefónica pública conmutada). Asterisk permite conectividad en
tiempo real entre las redes PSTN y redes VoIP.16
Es una aplicación de software libre (bajo licencia GPL) que proporciona
funcionalidades de una central telefónica (PBX). Como cualquier PBX, se puede
15http://tesis.pucp.edu.pe/repositorio/bitstream/handle/123456789/205/QUINTANA_DIEGO_DISENO_RED_TELEFONIA_IP_RAAP.pdf?sequence=2 16 http://linux.ctt-espe.edu.ec/12.pdf
23
conectar un número determinado de teléfonos para hacer llamadas entre sí e
incluso conectar a un proveedor de VoIP o bien a una RDSI tanto básicos como
primarios.
Para conectar teléfonos estándar analógicos son necesarias tarjetas
electrónicas telefónicas FXS o FXO fabricadas por Digium u otros proveedores,
ya que para conectar el servidor a una línea externa no basta con un simple
módem.
Asterisk incluye muchas características anteriormente sólo disponibles en
costosos sistemas propietarios PBX como buzón de voz, conferencias, IVR,
distribución automática de llamadas, y otras muchas más. Los usuarios pueden
crear nuevas funcionalidades escribiendo un dialplan en el lenguaje de script de
Asterisk o añadiendo módulos escritos en lenguaje C o en cualquier otro
lenguaje de programación soportado por Linux.17
Algunos de estos recursos son:
Música en espera para clientes en colas de espera, soportando streaming
de media así como música en MP3.
Filas de llamada donde agentes de forma conjunta atienden las llamadas y
monitorean dicha fila.
Integración para sintetización de la conversación (text-to-speech).
Registro detallado de llamadas (call-detail-records) para integración con
sistemas de tarificación.
17 http://es.wikipedia.org/wiki/Asterisk
24
Integración con reconocimiento de voz (Tal como el software de código
abierto para reconocimiento de voz).
Quizá lo más interesante de Asterisk es que soporta muchos protocolos VoIP
como pueden ser SIP, H.323, IAX y MGCP. Asterisk puede interoperar con
terminales IP actuando como un registrador y como Gateway entre ambos.
La versión estable de Asterisk 1.6.0.10 que utilizaremos en nuestro proyecto
está compuesta por los módulos siguientes:
Asterisk: Ficheros base del proyecto.
DAHDI: Soporte para hardware. Drivers de tarjetas. (Anteriormente
ZAPTEL).
Addons: Complementos y añadidos del paquete Asterisk. Opcional.
Libpri: Soporte para conexiones digitales. Opcional.
25
CAPÍTULO IV
4. CACTI
4.1. Descripción General
Cacti es una solución completa para la monitorización de redes mediante
gráficos y recopilación de datos, todo ello gracias a la potencia de RDDTool’s.
Podremos obtener información prácticamente en tiempo real de nuestros
routers, switches o servidores, trafico de interfaces, cargas, CPU, temperaturas,
etc.
El uso de herramientas que usan RRDTool como son Nagios, OpenNMS, ntop
y otros para almacenar datos como son el uso de ancho de banda, temperatura,
carga de CPU, etc. permiten que Cacti tenga siempre una fuente de donde
extraer información relevante para generar los gráficos necesarios por el
administrador.
Así, Cacti se ha convertido en una herramienta para vigilar, almacenar y
presentar estadísticas sobre nuestra red y dispositivos gracias a gráficos
MRTG, esto mediante el conjunto de scripts que lo conforman y que se ejecutan
en periodos de tiempo configurables en una interfaz web o en los propios
scripts.
Las ventajas más importantes al usar Cacti son:
Cacti puede ver las interfaces de los enrutadores, switches y el tráfico que
pasa a través de ellas, así como posibles errores.
Cacti puede indicar la cantidad de disco duro usado, carga de CPU,
temperatura de CPU, entre otras opciones del protocolo snmp, se puede
reaccionar y mandar notificaciones según rangos especificados
26
Cacti permite usar todo la funcionalidad de rrdgraph para definir gráficos y
automatizar como se los visualiza, permite organizar información en forma
jerárquica.
Se definen plantillas para re-usar definiciones (y evitar duplicación de
esfuerzos)
Localmente o usando LDAP, se pueden asignar niveles de acceso para la
administración y visualización de Cacti.
4.2. RRDTool
RRDtool es el acrónimo de Round Robin Database Tool. Se trata de una
herramienta que trabaja con una base de datos que maneja planificación según
Round-Robin. Esta técnica trabaja con una cantidad de datos fija, definida en el
momento de crear la base de datos, y un puntero al elemento actual.
El funcionamiento es el siguiente: se trata la base de datos como si fuese un
círculo, sobrescribiendo los datos almacenados con anterioridad una vez
alcanzada la capacidad máxima de la misma. Esta capacidad máxima
dependerá de la cantidad de información que se quiera conservar como
historial.
Su finalidad principal es el tratamiento de datos temporales y datos seriales
como temperaturas, transferencias en redes, cargas del procesador, etc.
Algunos proyectos que utilizan RRDtool son: Cacti, Ganglia, JFFNMS, Lighttpd,
MRTG, Munin, Smokeping, Zenoss, etc.
27
4.2.1. Tipos de Datos que Soporta Cacti
Podemos almacenar en nuestra base de datos cualquier tipo de dato siempre y
cuando se trate de series temporales, lo que implica que se necesita de un
método para que cada cierto periodo de tiempo se lean estas variables y
puedan ser almacenadas por RRDTool.
De aquí que SNMP sea uno de los protocolos mayormente usados junto a
RRDTool para la obtención de datos, dado que su implementación permite
realizar consultas a los dispositivos y obtener las variables listas para ser
almacenadas.
4.2.2. Características de Cacti
Cacti tiene ciertos elementos claramente diferenciales que ayudan al momento
de comprender la manera en que realiza su trabajo, estos son:
4.2.2.1. Fuente de Datos
En la recopilación de datos, cacti requiere de una ruta con un script o
instrucción para ser ejecutada junto a cualquier dato que pueda ser requerido
como parámetro, Cacti añadirá esta tarea al Cron del servidor, de manera que
será ejecutada periódicamente obteniendo los datos que posteriormente se
almacenan en la BD de MySQL y que serán procesadas por RRDTool para su
actualización.
Las fuentes de datos pueden ser creadas de varias maneras. Por ejemplo, si se
quiere graficar el status de equipo de la red, se puede desarrollar un script que
permita hacer ping a dicho dispositivo y obtener una respuesta en milisegundos
28
adjuntando la IP como información adicional en nuestra RRDTool se tendría
una fuente de datos lista para ser usada en gráficos de disponibilidad.
4.2.2.2. Gráficos
Los gráficos que se pueden obtener en Cacti dependen de las fuentes que se
encuentren disponibles y habilitadas por la herramienta. Una vez que se ha
comprendido la manera en que RRDTool almacena la información y el tipo de
datos que almacena, podemos ver que Cacti puede desarrollar todo tipo de
gráficos. Esto en parte gracias a las funciones de consolidación que traen estas
herramientas, como obtención de promedios, máximos, mínimos entre otros.
Además que la presentación de estos gráficos por parte de Cacti permite una
visualización en listas, preliminares, por periodicidad, y esta una vista jerárquica
dentro de árboles que pueden ser aprovechados con fines organizacionales.
4.2.2.3. Manejo de Usuarios
Cacti permite realizar la administración de usuarios de manera embebida en la
aplicación, de tal manera que es posible la agregación de usuarios
concediéndole permisos puntuales a ciertas áreas de la aplicación. Así
podemos tener usuarios que cumplan la tarea de administradores, configurando
parámetros de consultas entre otras tareas, como también usuarios a quienes
solo se les permita acceder a los gráficos finales de la aplicación.
4.2.2.4. Plantillas
29
Cacti permite la creación de varias plantillas para hosts, fuentes de datos,
métodos de obtención de datos y gráficos. De manera que en el caso de tener
muchos dispositivos similares solo hará falta asignar las plantillas
correspondientes y cacti generara los recursos necesarios para obtener los
datos de estos dispositivos y la generación posterior de sus respectivos
gráficos. Las plantillas son opcionales y son más bien una herramienta para
facilitar el trabajo del administrador, siempre quedará la opción de crear
elementos particulares.
4.3. Principios de Funcionamiento
La manera en cacti trabaja se puede diferenciar en tres tareas:
Figura 5 Funcionamiento Cacti
4.3.1. Data Retrieval – Obtención de Datos
30
La recuperación de datos es manejada mediante un script poller que se
encuentra en el directorio de instalación de Cacti. Se realiza una configuración
para que sea ejecutado periódicamente, por ejemplo, usando el demonio Cron
en las distribuciones Linux.
La obtención de datos se realiza además de manera remota, valiéndonos de
protocolos como snmp o de scritps programados en diferentes lenguajes, ya
sean php, python, perl, bash, etc. una vez configurados el script poller de Cacti
los ejecutará y obtendrá los datos requeridos. Cacti genera logs para cada una
de las ejecuciones en las que podemos observar si todo se realizó
correctamente.
4.3.2. Data Storage – Almacenamiento de Datos
Como se indico anteriormente, Cacti se apoya en RRDTool para la gestión de
los datos. Sin embargo, también se hace uso de MySQL para el
almacenamiento de parámetros y configuraciones útiles al momento de realizar
la recolección de datos.
RRDTool se encarga de hacer el proceso de verificación en sus archivos, para
asegurarse si aún no están fuera del periodo configurado, en caso de estarlos
los comprime y los almacena en la base de datos correspondiente, luego los
elimina de los archivos RRD con el fin de optimizar recursos. A estos datos
RRDTool puede adjuntar resultados de funciones como máximos, mínimos,
promedio y últimos.
4.3.3. Data Presentation – Presentación de Datos
Cacti es una herramienta a la cual podemos acceder mediante un navegador
web. Lo que permite un acceso prácticamente universal en cuanto a
31
dispositivos y que gracias a la administración de usuarios integrada facilita
mucho la gestión del sitio frente a posibles intrusos.
La manera en que RRDTool almacena los datos hace que los gráficos
presentados por Cacti se puedan ajustar acorde a las necesidades del
administrador. Gracias a las plantillas se puede definir que características se
desea en las gráfica final sean leyendas, estadísticos, valores entre otros; y
pudiendo ser organizado en grupos diarios, semanales, mensuales, etc.
4.4. Arquitectura de Cacti
Cacti presenta la siguiente arquitectura.
32
Figura 6 Arquitectura Cacti18
Donde sobresale su infraestructura LAMP, que es el acrónimo de ciertos
sistemas que se caracterizan por el uso de las siguientes herramientas:
Linux, el sistema operativo; En algunos casos también se refiere a LDAP.
Apache, el servidor web.
MySQL/MariaDB, el gestor de bases de datos.
18 https://www.scribd.com/doc/30455122/Procedimiento-Para-La-Instalacion-de-Cacti
33
Perl, PHP, o Python, los lenguajes de programación.
4.5. Ampliación de la funcionalidad de recopilación de datos
Cacti como ya se ha explicado, permite la recolección de datos mediante un
poller que se ejecuta periódicamente gracias a una tarea programada, sin
embargo, la función de este poller consiste en la ejecución de ciertos scripts
que pueden estar programados en diferentes lenguajes y que serán quienes
realicen las consultas a los diferentes dispositivos. Para entender de mejor
manera las posibilidades de Cacti hace falta conocer la estructura general que
deberían tener los scripts personalizados, y la manera en que el protocolo
SNMP trabaja, ya que puede facilitar en gran manera la recolección de la
información. Así mismo, con un conocimiento previo de este protocolo, se
logran establecer tareas de reacción frente a los datos obtenidos.
4.5.1. SNMP
El protocolo simple de gestión de red (SNMP) es un protocolo de la capa de
aplicación que facilita el intercambio de información de administración entre
dispositivos de red. Permitiendo a los administradores gestionar el rendimiento
y funcionamiento, encontrar y solucionar problemas, planificar el crecimiento
futuro de la red. En un principio SNMP se diseñó con el propósito de hacer
posible la supervisión de forma sencilla y resolución de problemas en
enrutadores y bridges; con su ampliación, este protocolo puede ser utilizado
para supervisar y controlar: enrutadores, conmutadores, hubs, servidores,
estaciones Windows y Unix, etc.
Se puede considerar al siguiente como un posible modelo de SNMP:
34
Figura 7 Proceso de Administración
Donde se identifican cuatro componentes:
Nodos de Administración
Estaciones Administradas
Información de Administración
Un protocolo de Administración
Las estaciones administradas pueden ser hosts, routers, switchs, o en nuestro
caso una Raspberry Pi o un servidor de VoIP, cuyo fin es el de comunicar
información al mundo exterior.
35
4.5.1.1. Componentes SNMP
Se compone básicamente de tres de partes para lograr el funcionamiento
requerido: Consola de Administración, Agentes y MIB.19
Agentes – es un programa que se encuentra en un dispositivo de red
siempre que sea administrable.
Consola de Administración – es un programa que se encuentra en una
estación de trabajo y que se encarga de indagar los agentes usando SNMP.
MIB – es una base de datos que contiene una lista de objetos administrados
accesibles por el agente y que pueden ser manipulados vía SNMP.
Cada una de estas partes cumple con ciertas funciones, pero entre las
principales podríamos decir que son las siguientes:
Agentes – Posee una vista general de MIB estándar para internet más un
grupo pequeño de extensiones. No es necesario contar con todas las
variables definidas para una MIB, con lo cual se puede simplificar su uso en
dispositivos pequeños que son parte de la red. Tiene dos tareas, la primera
que es indagar las variables de la MIB para recolectar datos y la segunda
que es manipular estas variables para entregar información al dispositivo.
Consola de Administración – Se encarga de la recolección de información
una vez que indaga en las variables definidas en los dispositivos,
19 Kornel.Terplan, “Communication Networks Management”, Prentice Hall
36
generalmente se cuenta con una interfaz que facilita la identificación de los
agentes que pertenecen a la red.
MIB – Las MIB se encuentran divididas en cuatro áreas: Atributos del
sistema, Atributos privados, Atributos experimentales y Atributos de
directorio.
4.5.1.2. Representación de la Información
Todos los objetos guardados en una MIB tienen un identificador único. Este
identificador es una secuencia de números positivos separados por puntos, que
se asignan acorde a un árbol estándar mundial y que es único para cada objeto
por lo que se lo conoce como OID. Un bosquejo del árbol se puede ver en la
siguiente figura.
37
Figura 8 Estructura general del MIB
Por ejemplo, el objeto sysName nos informa sobre el nombre del sistema, y
puede ser alcanzado con la siguiente ruta: 1.3.6.1.2.1.1.5. Hay que resaltar la
existencia del nodo enterprises (1.3.6.1.4.1). Bajo este nodo, cada fabricante
puede incorporar su propio subárbol que permita gestionar sus dispositivos.
Otro nodo especial es el nodo con etiqueta experimental (1.3.6.1.3), ya que bajo
este nodo se colocan aquellos objetos que están en fase de pruebas y aún no
son un estándar.
La MIB se encuentra escrita con la sintaxis ASN.1, que es la usada para definir
la estructura de las variables que se van a gestionar. Luego es necesario
también definir la sintaxis para la transferencia de la información en la red. El
ASN.1 define tres tipos de objetos:
38
Tipos, que definen el tipo de datos y que suelen escribirse con mayúscula
inicial
Valores, que son las variables de información y que se escriben en
minúscula.
Macros, que se usan para cambiar la gramática y se escriben con
mayúscula.
4.5.1.3. Comunidades
Se denomina comunidad (community) a un conjunto de gestores y a los
objetos gestionados. A las comunidades se les asignan nombres, de tal forma
que este nombre junto con cierta información adicional sirva para validar un
mensaje SNMP y al emisor del mismo.
Así, por ejemplo, si se tienen dos identificadores de comunidad "total" y
"parcial", se podría definir que el gestor que use el identificador "total" tenga
acceso de lectura y escritura a todas las variables de la base de
administración de información, MIB (Management Information Base), mientras
que el gestor con nombre de comunidad "parcial" sólo pueda acceder para
lectura a ciertas variables del MIB.
4.5.1.4. Mensajes SNMP
SNMP define cinco tipos de mensajes:
Get Request: Para leer el valor de una o varias variables del MIB.
Get Next Request: Para realizar lecturas secuenciales a través del Mffi.
Get.Response: Es el mensaje de respuesta a un Set Request, Get Request
o Get Next Request.
39
Set Request: Mensaje enviado para establecer el valor de una variable.
Trap: A través de este mensaje se hacen notificaciones de eventos.
Estos cinco tipos de mensajes SNMP son encapsulados en datagramas UDP.
Los mensajes de petición y respuesta son enviados al puerto 161, mientras
que las notificaciones de eventos usan el puerto 162.
4.5.2. Scripts para Cacti
La forma más sencilla para extender la funcionalidad de recopilación de datos
de Cacti es a través de scripts externos. Cacti viene con una serie de scripts
listos para ser usados que se encuentran en el directorio /scripts. Estos scripts
son utilizados como métodos de entrada de datos y siempre se encuentran
presentes en una instalación nueva de Cacti.
Para lograr que Cacti llame un script externo para recopilar datos se debe crear
un nuevo método de entrada de datos, asegurándose de especificar una
combinación Script/Comando para el campo Tipo de Entrada en la consola de
mando. Para recopilar los datos utilizando el método de Entrada de Datos, Cacti
ejecuta el comando por consola especificado en el campo Cadena de Entrada
en la consola de mando. Debido a esto, se puede tener a Cacti ejecutando
cualquier comando de consola o llamar a cualquier secuencia de comandos
contenidas en un programa que puede ser escrito en casi cualquier idioma.
En general, lo que Cacti valida en la recolección de data es el formato de la
misma. Cuando se define un Método de Entrada, Cacti requiere que se defina
los campos de salida que se tendrá para dicho método. El número de datos que
se configurar en esta parte como salida es relevante porque de esto depende el
número de datos que debe entregar nuestro script.
40
Por ejemplo, para un método de entrada con varios campos la declaración que
se hace debería ser similar a la siguiente:
<fieldname_1>:<value_1> <fieldname_2>:<value_2> ...
<fieldname_n>:<value_n>
Luego para una declaración de 3 variables, por ejemplo var1, var2 y var3, se
tendrá que crear un script cuya salida sea de la siguiente manera:
Var1:0.40 var2:0.32 var3:0.01
Por último, se debe tener presente que la ejecución de estos scripts se los debe
realizar usando un usuario que goce de privilegios de lectura y escritura en la
instalación Cacti.
41
CAPÍTULO V
5. DESARROLLO, INSTALACIÓN Y CONFIGURACIONES
5.1. Instalación y configuración de RANCID
Rancid requiere la instalación de los paquetes expect y cvs antes de poder ser
instalado, para lo cual ejecutamos el siguiente comando:
shell> apt-get install expect cvs
Para la creación de un usuario de rancid es necesaria la ejecución de los
siguientes comandos en consola (este usuario será el encargo de ejecutar
todos los procesos relacionados con rancid):
shell> adduser --home /home/rancid rancid
Hace falta crear un grupo que lo llamaremos netadm y que eventualmente
tendrá acceso al directorio Rancid:
shell> groupadd netadm
Creamos un usuario llamado rancid que será el usado para ejecutar los
backups de los dispositivos de la red cada noche. Luego es necesario agregarlo
al grupo netadm y configurar su directorio propio /usr/local/Rancid, con el
siguiente comando:
shell> useradd -g netadm -c "Network Backups" -d /usr/local/rancid rancid
42
Rancid se encuentra en la versión 3.2, y este puede ser descargado desde la
siguiente página:
http://www.shrubbery.net/rancid/
Una vez que hemos descargado el archivo, es neceario descomprimirlo (en el
directorio /usr/src para nuestro caso):
shell> cp rancid-3.2.tar.gz /usr/src
shell> cd /usr/src
shell> tar xvfz rancid-3.2.tar.gz
shell> cd rancid-3.2
Los siguientes pasos realizarán la instalación de nuestro paquete rancid y serán
ejecutados como root, sin embargo el usuario Rancid debe ser el propietario del
directorio (chown -R rancid:rancid /usr/local/rancid):
shell> ./configure -prefix=/usr/local/rancid
Luego es necesario configurar el archivo de contraseñas cloginrc.sample. Para
esto es necesario copiarlo en el directorio /usr/local/rancid/ como el archivo
oculto /usr/local/rancid/.cloginrc:
shell> cp cloginrc.sample /usr/local/rancid/.cloginrc
Finalmente es necesario configurar los permisos correctos en el archivo
.cloginrc para permitir la lectura del usuario rancid y del nuevo grupo de
usuarios netadm. También será necesario cambiar los propietarios del directorio
en una manera similar:
#chmod 0640 /usr/local/rancid/.cloginrc
43
#chown -R rancid:netadm /usr/local/rancid/
#chmod 770 /usr/local/rancid/
Ahora que tenemos finalizada la instalación de Rancid, es necesaria la
configuración de la herramienta para que empiece a trabajar de manera
adecuada.
5.1.1. Configuración de RANCID
Se crea un grupo llamado administradores en la configuración de rancid
editando el archivo /home/rancid/etc/rancid.conf.All, los archivos relacionados
con este grupo serán almacenados en un subdirectorio del mismo nombre
dentro de la carpeta var del directorio Rancid. Este será
/usr/local/var/administradores.
Por default Rancid filtra las contraseñas de salida y las variables string del
SNMP. Es preferible setear las opciones FILTER_PWDS y NOCOMMSTR a
"NO" para prevenir esta configuración:
LIST_OF_GROUPS="administradores"
FILTER_PWDS=NO; export FILTER_PWDS
NOCOMMSTR=NO; export NOCOMMSTR
Rancid es capaz de enviar los mails de estado a una lista de mails que se
define en el archivo /etc/aliases. El grupo de Rancid "administradores" necesita
tener permisos de los grupos denominados rancid-admin-networking y rancid-
networking. Un grupo llamado "alldevices" debe tener los grupos llamados
rancid-admin-alldevices y rancid-alldevices.
Para nuestro propósito usaremos un mail privado en la configuración, a fin de
poder comprobar las notificaciones:
44
shell> Rancid email addresses
rancid-admin-networking: rancid-networking
rancid-networking: admin
admin: [email protected]
Esta lista de alias de correo deben ser añadidas a la base de datos de postfix
con el comando newaliases:
shell> newaliases
Los siguientes pasos deben ser ejecutados mediante el usuario rancid. Para
lograrlo debemos ejecutar el comando su junto al usuario requerido:
shell> su – rancid
El comando rancid-cvs es necesario para crear el directorio
/usr/local/var/administradores y es asociado con la base de datos y con la lista
que contiene la lista de dispositivos de la red:
shell> /usr/local/rancid/bin/rancid-cvs
No conflicts created by this import
cvs checkout: Updating administradores
cvs checkout: Updating administradores/configs
cvs add: scheduling file `router.db' for addition
cvs add: use 'cvs commit' to add this file permanently
RCS file: /usr/local/rancid/ /var/CVS/administradores/router.db,v
45
done
Verificamos en el router.db;
/usr/local/rancid/ /var/CVS/administradores/router.db,v <-- router.db
initial revision: 1.1
El archivo README es de mucha ayuda, entonces haremos una copia antes de
eliminar el subdirectorio.
shell> cp /rancid-3.2/README .
shell> rm -rf /rancid-3.2
Añadiremos el archivo Rancid correspondiente en el demonio Cron para
programar la realización de los backups regularmente, ubicado en
/usr/local/rancid/bin/rancid-run:
shell> crontab –e
# Ejecución con periodos de 1 hora
1 * * * * /usr/local/rancid/bin/rancid-run
# Limpieza de los logs de configuración
0 23 * * * /usr/bin/find /usr/local/rancid/var/logs -type f -mtime +2 -exec rm {} \;
Debemos configurar la lista de dispositivos de red y los archivos de contraseñas
antes de que las configuraciones para realizar los backups puedan ser
ejecutadas, pero primero es necesario revisar los principales directorios que
contienen estos archivos.
46
5.1.1.1. Archivo rancid router.db
El archivo router.db es la lista de dispositivos que se tiene para realizar los
backups. Este archivo contiene el siguiente formato:
nombre-dns-o-direccion-ip:tipo-dispositivo:estado
Donde nombre-dns-o-direccion-ip corresponde al nombre del host o la dirección
ip del dispositvo, tipo-dispositivo es el tipo de dispositivo o el sistema operativo
con el que el dispositivo trabaja y estado (que puede ser up o down) que
determina si el back se debe realizar o no. Este es el ejemplo para un switch
Cisco con la dirección IP 10.3.0.1:
10.3.0.1:cisco:up
5.1.1.2. Archivo Rancid .clogin.rc
El archivo .clogin.rc contiene una lista de contraseñas que Rancid usará para
los obtener los backups. El archivo que viene en el paquete de instalación de
Rancid contiene varios ejemplos y contiene además una explicación para su
configuración. Desafortunadamente varios de estos ejemplos no vienen
comentados, por lo que se requiere hacerlo de forma manual. El siguiente es
uno de los ejemplos encontrados en la mayoría de escenarios.
# Sample .clogin.rc file
################################################################
# Device 172.15.1.1 has a unique username and password, but
# doesn't logins do not get the enable prompt.
# If the device prompts for a username, Rancid will use the Linux
# "rancid" username and the first password in the list. If only a
# login password is requested, rancid uses the first password in the
47
# list. The second password is the "enable" password.
################################################################
add password 172.15.1.1 {telnet-password} {enable-password}
################################################################
# Devices with DNS names ending in my-web-site.org in the router.db
# file or beginning with 172.16. have a different set of passwords.
# If the device prompts for a username, Rancid will use the Linux
# "rancid" username and the first password in the list. If only a
# login password is requested, rancid uses the first password in the
# list. The second password is the "enable" password.
################################################################
add password *.yourwebsite.com {telnet-password} {enable-password}
add password 172.16.* {telnet-password} {enable-password}
################################################################
# Everything else uses these passwords. Rancid will attempt to use
# telnet then SSH for logins
################################################################
add password * {telnet-password} {enable-password}
add method * telnet ssh
5.1.2. CvsWeb
Para la instalación de CvsWeb es necesario ejecutar los siguientes comandos
en consola:
shell> apt-get install cvsweb
Y modificar la configuracion de cvsweb creando el grupo "administradores" en el
archivo:
48
/etc/cvsweb.conf
@CVSrepositories = (
'local' => ['Local Repository', '/var/lib/cvs'],
'debianhelp' => ['administradores devices',
'/home/rancid/var/rancid/CVS'],
);
El directorio donde se instalaron los iconos y archivos css de cvsweb no se
encuentra en /var/www, por lo que es necesario crear un link simbólico:
# ln -s /usr/share/cvsweb /var/www/cvsweb
Ahora la historia de las configuraciones está disponible vía cvsweb en la
siguiente dirección:
http://ipservidor/cgi-bin/cvsweb/debianhelp/configs/?cvsroot=debianhelp
En donde veremos una interfaz con los archivos que se han ido han
almacenando si todo se hizo de la manera correcta.
49
Figura 9 Interfaz CVSWeb
Con la configuración realizada correctamente obtendremos las notificaciones de
nuestro servidor cada vez que detecte un cambio en el estado de nuestros
dispositivos en el email.
Figura 10 Correos de Notificación – RANCID
En el cual nos mostrará cual fue el evento que genero la notificación.
50
Figura 11 Cambios en Estado de Dispositivo - RANCID
5.2. Instalación y configuración Asterisk – Freepbx
Para la instalación de Freepbx sobre una maquina virtual es necesario
descargarse la imagen disponible en su sitio:
http://www.schmoozecom.com/distro-download.php
Una vez instalado es necesario habilitar el almacenamiento en MySQL para lo
cual ejecutamos los siguientes comandos:
shell> mysqladmin -u root create asterisk
shell> mysqladmin -u root create asteriskcdrdb
shell> mysql -u root asterisk < SQL/newinstall.sql
shell> mysql -u root asteriskcdrdb < SQL/cdr_mysql_table.sql
51
Es necesario conceder permisos en la base de datos MySQL para poder
acceder a la misma y realizar consultas:
mysql> mysql -u root -e "GRANT ALL PRIVILEGES
ON asterisk.* TO asteriskuser@localhost
IDENTIFIED BY '${ASTERISK_DB_PW}';"
mysql> mysql -u root -e "GRANT ALL PRIVILEGES ON asteriskcdrdb.* TO
asteriskuser@localhost
IDENTIFIED BY '${ASTERISK_DB_PW}';"
mysql> mysql -u root -e "flush privileges;"
Una vez instalado Asterisk - Freepbx y configurado MySQL es necesario
agregar el usuario que se conectará vía remota y hará la recolección de los
datos necesarios, para esto ejecutamos los siguientes comandos desde
MySQL:
mysql> USE MYSQL;
mysql> INSERT INTO USER ( host, user, password ) VALUES ( ipservidor,
usuario, PASSWORD('unacontraseña') );
mysql> GRANT ALL ON asteriskcdrdb.* TO 'user'@'*' IDENTIFIED BY
'unacontraseña';
mysql> flush privileges;
Agregado el usuario que se conectará vía remota, se necesita habilitar las
conexiones remotas en la configuración de MySQL, esto editando el archivo
que se encuentra en el directorio /etc/mysqml/my.cnf y agregando la siguiente
línea en caso de no constar:
52
bind-address = ipservidor
Adicionalmente tal vez sea necesario abrir el puerto 3306 (MySQL) en el firewall
del servidor de bases de datos. Por ejemplo, si en la dirección IP 10.3.0.103
donde atiende el servidor MySQL está asignada a la interfaz eth1, y se desea
permitir el acceso sólo al host 10.3.0.101, debemos ejecutar:
shell> iptables -A INPUT -i eth1 -s 10.3.0.101 -p tcp --destination-port 3306 -j
ACCEPT
Luego guardar la configuración del firewall mediante:
# service iptables save
5.3. Configuración de la Raspberry Pi
Para el micro computador Raspberry Pi se va a necesitar la instalación del
sistema operativo en una memoria SD, para lo cual hay que descargar la
imagen desde su sitio: http://www.raspberrypi.org/downloads/
Y el siguiente paso consiste en copiar la imagen en la memoria SD, para lo cual
se debe:
Insertar la tarjeta SD en el lector de tarjetas SD y comprobar qué letra de
unidad fue asignada (por ejemplo G :). Se puede utilizar la ranura para
tarjetas SD (si se dispone de uno) o un adaptador SD barato en un puerto
USB.
Descargar la utilidad Win32DiskImager desde
http://sourceforge.net/projects/win32diskimager/ (también es un archivo zip);
este se puede ejecutar desde una unidad USB.
Extrae el archivo ejecutable desde el archivo zip y ejecutar la utilidad
Win32DiskImager; es preferible ejecutar la utilidad como administrador.
53
Seleccionamos el archivo de imagen que se ha extraído anteriormente.
Seleccionamos la letra de unidad de la tarjeta SD en la caja del dispositivo.
Se debe tener cuidado de seleccionar la unidad correcta; si se escoge por
error el incorrecto se puede incluso destruir los datos en el disco duro de la
computadora.
Hacemos clic en Escritura y esperamos a que la escritura se complete.
Salimos del reproductor de imágenes y expulsamos la tarjeta SD.
Con este procedimiento tendremos nuestro sistema operativo Raspbian
cargado en la SD y listo para usarse con nuestra Raspberry Pi.
5.3.1. Configuración del Sensor DS18B20
Figura 12 Sensor DS18B20
Para acoplar el sensor DS18B20 a nuestra Raspberry Pi vamos a seguir la
siguiente configuración, teniendo en cuenta la numeración de los Pin de la
GPIO en la siguiente manera:
54
Figura 13 GPIO Disposición de Pines
Conectamos al pin 1 (GND) de nuestro DS18B20 con el pin 6 (GND) en
nuestra RPi.
Conectamos al 2 (DQ) de nuestro DS18B20 con el pin 7 (GPIO4) en
nuestra RPi.
Conectamos al 3 (VDD) de nuestro DS18B20 con el pin 1 (3V3) en nuestra
RPi.
Finalmente, colocamos una resistencia de 4k ohm entre los pines 2 y 3 de
nuestro DS18B20.
55
Figura 14 Conexión Sensor - Raspberry Pi
Una vez acoplado podemos ejecutar los siguientes comandos para comprobar
que se encuentra funcional:
Figura 15 Resultado del Sensor de Temperatura
A continuación crearemos un script que permita tomar la información que
registra el sensor con su ejecución desde la consola del sistema:
#bin/bash
while True:
tfile = open("/sys/bus/w1/devices/28-0000054c9ed6/w1_slave")
text = tfile.read()
tfile.close()
temperaturedata = text.split()[-1]
56
temperature = float(temperaturedata[2:])
temperature = temperature / 1000
temp = str(temperature)
break
print "temperature:" + temp
De manera que cuando llamamos al script obtenemos:
shell> /opt/temp_cacti.sh
Respuesta: temperature:40.6
5.3.2. SNMP en Raspberry Pi
EL primer paso es realizar la instalación de snmp en nuestra Raspberry Pi para
lo cual ejecutamos el comando:
shell> apt-get install snmpd
Una vez instalado necesitamos configurar uno de sus archivos para permitir la
escritura de OID’s y para extender la funcionalidad habilitando una nueva OID
privada, para lo cual accedemos al archivo de configuración ubicado en
/etc/snmp/snmpd.conf en el cual modificamos las siguientes líneas:
Si no se encuentra la instrucción para habilitar el puerto de conexión añadimos
agentAddress udp:161
57
Verificamos que las líneas que hacen referencia a la comunidad se encuentren
el modo de lectura y escritura
rwcommunity public IP OF REMOTE MACHINE
rwcommunity public localhost
Por último en este archivo habilitamos el OID privado que necesitaremos para
enviar nuestra información
extend .1.3.6.1.4.1.65535.1 /bin/bash "/usr/bin/sudo /opt/temp_cacti.sh"
Una vez realizada la configuración podemos ejecutar el siguiente comando para
comprobar que se encuentra funcional el servicio snmp:
shell> snmpwalk -v 1 -c public localhost
Y en particular se puede constatar si nuestra OID se encuentra bien configurada
con el comando:
shell> snmpwalk -c public -v 1 localhost iso.3.6.1.4.1.65535.1
Response:
iso.3.6.1.4.1.65535.1.1.0 = INTEGER: 1
iso.3.6.1.4.1.65535.1.2.1.2.9.47.98.105.110.47.98.97.115.104 = STRING:
"/usr/bin/sudo /opt/temp_cacti.sh"
iso.3.6.1.4.1.65535.1.2.1.3.9.47.98.105.110.47.98.97.115.104 = ""
iso.3.6.1.4.1.65535.1.2.1.4.9.47.98.105.110.47.98.97.115.104 = ""
iso.3.6.1.4.1.65535.1.2.1.5.9.47.98.105.110.47.98.97.115.104 = INTEGER: 5
iso.3.6.1.4.1.65535.1.2.1.6.9.47.98.105.110.47.98.97.115.104 = INTEGER: 1
58
iso.3.6.1.4.1.65535.1.2.1.7.9.47.98.105.110.47.98.97.115.104 = INTEGER: 1
iso.3.6.1.4.1.65535.1.2.1.20.9.47.98.105.110.47.98.97.115.104 = INTEGER: 4
iso.3.6.1.4.1.65535.1.2.1.21.9.47.98.105.110.47.98.97.115.104 = INTEGER: 1
iso.3.6.1.4.1.65535.1.3.1.1.9.47.98.105.110.47.98.97.115.104 = STRING:
"temp:40.6"
iso.3.6.1.4.1.65535.1.3.1.2.9.47.98.105.110.47.98.97.115.104 = STRING:
"temp:40.6"
iso.3.6.1.4.1.65535.1.3.1.3.9.47.98.105.110.47.98.97.115.104 = INTEGER: 1
iso.3.6.1.4.1.65535.1.3.1.4.9.47.98.105.110.47.98.97.115.104 = INTEGER: 0
iso.3.6.1.4.1.65535.1.4.1.2.9.47.98.105.110.47.98.97.115.104.1 = STRING:
"temp:40.6"
Para lograr consultar únicamente la información que nos compete
comprobamos que responde correctamente el comando:
shell> snmpget -c public -v 1 localhost
iso.3.6.1.4.1.65535.1.3.1.1.9.47.98.105.110.47.98.97.115.104
Respuesta:
iso.3.6.1.4.1.65535.1.3.1.1.9.47.98.105.110.47.98.97.115.104 = STRING:
"temp:40.6"
5.3.3. Configuración del Driver L298N y Micromotor de dos pasos
Para la conexión del driver y el micromotor es necesario basarse en el siguiente
diagrama:
59
Figura 16 Diagrama de Conexión Raspberry Pi y L298N
Se puede probar que esta funcional creando un script en python como el
siguiente:
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(13, GPIO.OUT)
GPIO.setup(15, GPIO.OUT)
GPIO.output(13, GPIO.HIGH)
sleep(1)
GPIO.output(13, GPIO.LOW)
GPIO.output(15, GPIO.HIGH)
60
sleep(1)
GPIO.output(15, GPIO.LOW)
GPIO.cleanup()
Al ejecutarlo se deberá constatar la respuesta del motor girando hacia adelante
durante un segundo y luego en reversa:
/python /opt/motor.py
Dado que buscamos que el motor responda de manera diferente acorde a
ciertos parámetros crearemos 3 scripts que se ejecutaran dependiendo de la
situación que se presente:
El primer script detiene el movimiento de retroceso y enciende el movimiento
hacia adelante, Motor1.py:
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(13, GPIO.OUT)
GPIO.setup(15, GPIO.OUT)
GPIO.output(15,False)
GPIO.output(13,True)
sleep(10)
GPIO.cleanup()
El segundo script detiene el movimiento hacia adelante y enciende el
movimiento de retroceso, Motor2.py:
61
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(13, GPIO.OUT)
GPIO.setup(15, GPIO.OUT)
GPIO.output(13,False)
GPIO.output(15,True)
sleep(5)
GPIO.cleanup()
El tercer script detiene el movimiento del micromotor, Motor3.py:
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(13, GPIO.OUT)
GPIO.setup(15, GPIO.OUT)
GPIO.output(13,False)
GPIO.output(15,False)
GPIO.cleanup()
Para la ejecución automática de estos scripts crearemos una tarea que
compruebe los parámetros en base a una OID de nuestra Raspberry Pi, esto
gracias al demonio Cron modificando el archivo ubicado en /etc/cron.d/motor
con la linea:
*/1 * * * * root /bin/sh /opt/monitor.sh
62
Donde el script monitor.sh contiene las siguientes instrucciones que se indican
a continuación tomando en cuenta los rangos presentados en la Tabla 1:
#! /bin/bash
data =$(/usr/bin/snmpget –v2c –c public localhost iso.3.6.1.2.1.1.6.0)
var= `echo $data | awk –F”\”” ‘{print $2}’`
echo $var
if(( $(echo “$var > 20” | bc -l) )) && (( $(echo “$var < 25” | bc -l) )); then
python /opt/motor1.py
elif (( $(echo “$var > 25” | bc -l) ))
then
python /opt/motor2.py
else
python /opt/motor3.py
fi
Con nuestro sensor y nuestro motor acoplados a la Raspberry Pi, tenemos a
nuestros dispositivos ensamblados como se muestra en a Figura 14.
63
Figura 17 Raspberry Pi- Sensor de Temperatura - Driver L298N
5.4. Instalación de Cacti
Cacti requiere tener instalado el siguiente software en el sistema.
RRDTool 1.0.48 o superior
MySQL 3.23 o superior, 4.0.20d o superior para configuraciones avanzadas
PHP 4.1 o superior, 4.3.6 o superior para configuraciones avanzadas
En cuanto a requerimientos necesarios se tiene:
httpd
php
php-mysql
php-snmp
64
mysql
mysql-server
net-snmp
Con estos paquetes instalados, para la instalación de Cacti es necesaria la
ejecución del siguiente comando:
# apt-get install cacti
Esto instalará todos los paquetes necesarios como MySQL y RRDTool
Para cacti es necesario crear un nuevo usuario con el siguiente comando:
adduser cacti
Para la creación de la base de datos y con el esquema que requiere Cacti en
MySQL es necesario ejecutar el siguiente comando:
shell> mysqladmin --user=root create cacti
Luego se requiere importar la base por default de Cacti:
shell> mysql cacti < cacti.sql
Opcional: Creación de usuario y contraseña en MySQL para Cacti.
shell> mysql --user=root mysql
mysql> GRANT ALL ON cacti.* TO cactiuser@localhost IDENTIFIED BY
'somepassword';
mysql> flush privileges;
Se debe editar el archivo include/config.php y especificar el usuario, la
contraseña y la base en MySQL.
65
$database_default = "cacti";
$database_hostname = "localhost";
$database_username = "cactiuser";
$database_password = "cacti";
Debemos asignar los permisos necesarios y adecuados en la carpeta de
instalación de cacti para permitir la generación de gráficos y archivos logs. Se lo
puede realizar ejecutando el siguiente comando desde el interior de la carpeta
de instalación de cacti.
shell> chown -R cactiuser rra/ log/
(Es necesario elegir un usuario de cacti valido ya que se requiere que este
ejecute la captura de data en los poller.)
Se debe añadir un comando similar al siguiente en el archivo que se encuentra
en /etc/crontab para la ejecución periódica del poller:
*/5 * * * * cactiuser php /var/www/html/cacti/poller.php > /dev/null 2>&1
Donde se reemplaza cactiuser con el usuario válido especificado en el paso
anterior.
Se debe reemplazar /var/www/html/cacti/ con el path completo de Cacti. Con
esto en el navegador nos dirigimos a la siguiente dirección:
http://ipservidor/cacti/
Hay que hacer login con el usuario admin, se nos pedirá entonces cambiar la
contraseña. Por último hay que asegurarse que los directorios indicados en las
66
pantallas de ingreso sean las correctas y se tendrá instalado cacti en nuestro
equipo.
Una vez configurado cacti se debe desarrollar métodos de captura y graficas.
5.4.1. Configuración para la recolección información de temperatura,
Crearemos un script en nuestra carpeta de instalación de cacti
/usr/share/cacti/site/scripts/rasp_temp.sh que contendrá las instrucciones para
obtener la data desde nuestra Raspberry Pi:
#!/bin/bash
/usr/bin/snmpget -c public -v 1 $1
iso.3.6.1.4.1.65535.1.3.1.1.9.47.98.105.110.47.98.97.115.104 |
/usr/bin/perl -e '<STDIN> =~ m/\"(temp:.*?)\"/; print $1;'
exit 0;
El mismo que tendrá como parámetro la dirección ip de nuestro dispositivo, y a
continuación comprobaremos que funciona correctamente:
Command:/bin/sh /usr/share/cacti/site/scripts/raspi_temp_cacti.sh 10.3.0.102
Response:temperature:40.6
Con el script funcionando correctamente, el siguiente paso será crear el método
de entrada de datos en la herramienta cacti, para lo cual procedemos como
sigue:
67
Figura 18 Cacti Método de Entrada - Temperatura
Configuramos luego una fuente de datos para el grafico donde especificamos el
método de ingreso de datos y la dirección IP que requiere el script, como se
indica:
Figura 19 Cacti Fuente de Datos - Temperatura
Y por último creamos un nuevo gráfico usando la fuente de datos que creamos
previamente:
68
Figura 20 Cacti Plantilla de Gráfico - Temperatura
5.4.2. Configuración para la recolección de datos del servidor Asterisk,
Para obtener los datos necesarios crearemos un script que se conecte al
servidor y extraiga la información requerida desde el mismo, teniendo en cuenta
69
que se ejecutará cada 5 minutos el script que se desarrolla tiene la siguiente
estructura:
<?php
$dbhost = '10.3.0.102:3306';
$dbuser = 'root';
$dbpass = 'unacontraseña';
$conn = mysql_connect($dbhost, $dbuser, $dbpass) or die ('Error connecting to
mysql');
$dbname = 'asteriskcdrdb';
mysql_select_db($dbname);
$query = "select date(calldate) as Dat, sum(duration) as duration
,count(duration) as callcount from cdr where calldate BETWEEN DATE_SUB(
NOW( ),INTERVAL '0:5:0'DAY_SECOND ) AND NOW( ) group by
date(calldate)";
$result = mysql_query($query);
while($row = mysql_fetch_array($result, MYSQL_ASSOC))
{ print "Duration:{$row['duration']} count:{$row['callcount']}"; }
mysql_close($conn);
?>
El mismo que al ejecutar nos devolverá los datos, con el siguiente formato:
Duration:26 count:9
Duration:205 count:14
Duration:88 count:15
70
Con esta información procedemos a crear un método de ingreso de
información, fuente de datos y un grafico similar al que usamos para el caso de
la temperatura en nuestra Raspberry Pi.
En el panel de administración nos vamos a la sección Input Method y creamos
un método de la siguiente manera:
Figura 21 Cacti Fuente de Datos - Asterisk
Con el método de entrada de datos definido es necesario crear una plantilla
para asignarla en una fuente de datos, por lo que en el panel de administración
escogemos la opción de plantillas de datos y configuramos una nueva plantilla
como se muestra en el gráfico:
71
Figura 22 Cacti Plantilla de Datos
Con la plantilla preparada ya es posible obtener una fuente de datos para
nuestro grafico, hay que ir a la opción Data Source en el panel de
administración y configurar una fuente nueva como la que se muestra a
continuación:
Figura 23 Cacti Fuente de Datos - Asterisk
72
Por último, debemos crear una plantilla para nuestro gráfico, asignando la
fuente de datos antes detallada, donde obtendremos el siguiente resultado:
Figura 24 Cacti Plantilla de Gráficos - Asterisk
5.5. Configuración para el envío de data al Raspberry Pi
Por último necesitamos hacer uso del comando SNMPSET para setear los
valores que tenemos en temperatura dentro de la OID elegida en nuestra
Raspberry Pi y que la tarea que se encuentra ejecutándose gracias al Cron de
nuestro dispositivo trabaje de manera correcta.
Para la temperatura hemos usado una OID pública de tipo string, para su envío
crearemos primero un script bash, que se encargará de tomar la información de
la temperatura remota y de setearla en el equipo remoto. Este script lo
ubicaremos en el directorio de scripts de Cacti y debe tener la siguiente
estructura:
#!/bin/bash
datos=$(/bin/bash /usr/share/cacti/site/scripts/rasp_temp.sh 10.3.0.102)
73
echo $datos
temperatura=`echo $datos | awk -F":" '{print $2}'`
/usr/bin/snmpset -v2c -c public 10.3.0.102 iso.3.6.1.2.1.1.6.0 s $temperatura
exit 0;
Por último, es necesario agregar una tarea más a nuestro demonio Cron, con la
finalidad de hacerla automática, para lo cual debemos agregar la siguiente línea
en nuestro archivo /etc/cron.d/snmprasp:
*/1 * * * * root /bin/sh /usr/share/cacti/site/scripts/snmpd.sh
74
CAPÍTULO VI
6. CONCLUSIONES Y RECOMENDACIONES
6.1. CONCLUSIONES
La herramienta Rancid usada para obtener respaldos de las
configuraciones de nuestros dispositivos, a pesar de resultar de simple
instalación y configuración, realiza una tarea sumamente importante en la
gestión de nuestra red. Y con los archivos que guarda se puede obtener
información para el análisis de tendencias en cuanto al crecimiento nuestra
red.
Las tecnologías que permiten brindar servicios de VoIP hoy en día se han
vuelto bastante sencillas de implementar, sin embargo las ventajas que
brindan son enormes. Por esto, los métodos de acceso a la información que
almacenan estos servidores resultan importantes al momento de su
monitoreo.
Cacti permite generar casi todo tipo de gráficos necesarios para la
administración y gestión de redes, siempre que la información pueda ser
representada dentro de series temporales, y permite mostrar ciertas
características de la información como picos y promedios.
Las características del poller que posee Cacti permite extender en gran
medida su funcionalidad, esto porque toma cualquier método de entrada
siempre y cuando cumpla con la condición de entregar un nombre de
75
variable y su dato; con lo que es posible desarrollar fuentes de datos
basados en scripts escritos en cualquier lenguaje de programación.
La microcomputadora Raspberry Pi es óptima para desarrollar varios
proyectos que involucren la comunicación entre una red y el mundo exterior,
en parte gracias a su módulo GPIO que permite la programación de sus
pines tanto para trabajar como receptores de información como para
emisores de información.
La cantidad de dispositivos lógicos existentes, como el driver L298N,
muestran que la funcionalidad de la Raspberry Pi como gestor y controlador
puede ser tan relevante como las necesidades del administrador lo
requieran.
6.2. RECOMENDACIONES
Es recomendable que el servidor en el que se implementan estas
herramientas de monitoreo sea depurado en cuanto a archivos de logs de
eventos, ya que podría llegar a saturarse el disco duro si no se realiza una
constante vigilancia en este aspecto.
Cuando se implementan proyectos que hacen uso de elementos
electrónicos como el presente, es recomendable usar materiales adecuados
para las conexiones, de manera que aseguremos un buen funcionamiento
de cada uno de los componentes.
76
Si bien Cacti es una herramienta que se encarga más de la parte de
visualización de información, es recomendable tener una diferenciación de
usuarios. Teniendo usuarios administradores encargados de la generación
y gestión de reportes, así como usuarios finales que tengan acceso solo a
la visualización de estos reportes.
77
GLOSARIO DE TERMINOS
A
Administración: Es la ciencia social aplicada o tecnología social que tiene por
objeto el estudio de las organizaciones, y la técnica encargada de la
planificación, organización, dirección y control de los recursos de una
organización, con el fin de obtener el máximo beneficio posible.
B
Base de Datos: Se le llama base de datos a los bancos de información que
contienen datos relativos a diversas temáticas y categorizados de distinta
manera, pero que comparten entre sí algún tipo de vínculo o relación.
C
CGI: Interfaz de entrada común, es una importante tecnología de la World Wide
Web que permite a un cliente (navegador web) solicitar datos de un programa
ejecutado en un servidor web.
CRAC: Unidades de Aire Acondicionado en Centros de Datos.
D
Data Center: Se denomina data center a aquella ubicación donde se
concentran los recursos necesarios para el procesamiento de la información de
una organización.
F
78
FXS: Es el conector en una central telefónica o en la pared de nuestro
hogar, que permite conectar un teléfono analógico estándar.
G
Gestión: es la asunción y ejercicio de responsabilidades sobre un proceso (es
decir, sobre un conjunto de actividades).
Gestor de base de datos: Es un conjunto de programas que permiten el
almacenamiento, modificación y extracción de la información en una base de
datos, además de proporcionar herramientas para añadir, borrar, modificar y
analizar los datos.
Gráficos MRTG: Es una herramienta, escrita en C y Perl por Tobias Oetiker y
Dave Rand, que se utiliza para supervisar la carga de tráfico de interfaces de
red.
I
Interfaz: Se utiliza para nombrar a la conexión física y funcional entre dos
sistemas o dispositivos de cualquier tipo dando una comunicación entre
distintos niveles.
L
Lenguaje de Programación: Es un lenguaje formal diseñado para expresar
procesos que pueden ser llevados a cabo por máquinas como las
computadoras.
79
Licencia GPL: Es la licencia más usada en el mundo del software y garantiza a
los usuarios finales (personas, organizaciones, compañías) la libertad de usar,
estudiar, compartir (copiar) y modificar el software.
M
Método de Entrada: Es un componente de un sistema operativo o de un
programa) que permite a los usuarios introducir caracteres y símbolos que no
se encuentran en su Dispositivo de entrada
Monitoreo: Es la acción y efecto de monitorear, el verbo que se utiliza para
nombrar a la supervisión o el control realizado a través de un monitor.
N
Navegador: Navegador web, o browser, es un software que permite el acceso
a Internet, interpretando la información de distintos tipos de archivos y sitios
web para que éstos puedan ser visualizados.
O
OID: Según la Unión Internacional de Telecomunicaciones (ITU) es un valor
único global asociado con un objeto que lo identifica sin ambigüedades.
P
PBX: Es cualquier central telefónica conectada directamente a la red pública de
telefonía por medio de líneas troncales para gestionar además de las llamadas
internas, las entrantes y salientes con autonomía sobre cualquier otra central
telefónica
80
Plantilla: Es un medio o aparato o sistema, que permite guiar, portar, o
construir, un diseño o esquema predefinido.
Programación: es el proceso de diseñar, codificar, depurar y mantener el
código fuente de programas computacionales.
Protocolo: Conjunto de reglas y estándares que controlan la transmisión de
mensajes durante la comunicación entre entidades que son parte de una red.
PSTN: Se define como el conjunto de elementos constituido por todos los
medios de transmisión y conmutación necesarios para enlazar a voluntad dos
equipos terminales mediante un circuito físico que se establece específicamente
para la comunicación y que desaparece una vez que se ha completado la
misma.
R
Reporte: Son informes que organizan y exhiben la información contenida en
una base de datos. Su función es aplicar un formato determinado a los datos
para mostrarlos por medio de un diseño atractivo y que sea fácil de interpretar
por los usuarios.
Respaldos: El respaldo de información es la copia de los datos importantes de
un dispositivo primario en uno ó varios dispositivos secundarios, ello para que
en caso de que el primer dispositivo sufra una avería electromecánica ó un error
en su estructura lógica, sea posible contar con la mayor parte de la información
necesaria para continuar con las actividades rutinarias y evitar pérdida
generalizada de datos.
81
Round-Robin: Es un método para seleccionar todos los elementos en un grupo
de manera equitativa y en un orden racional, normalmente comenzando por el
primer elemento de la lista hasta llegar al último y empezando de nuevo desde
el primer elemento.
S
Script: Es unprograma usualmente simple, que por lo regular se almacena en
un archivo de texto plano.
Sensor: Un sensor es un dispositivo capaz de detectar magnitudes físicas o
químicas, llamadas variables de instrumentación, y transformarlas en variables
eléctricas.
Servidor: Es una computadora que, formando parte de una red, provee
servicios a otras computadoras, recibe peticiones y envía respuestas.
Sistema Operativo: Conjunto de programas destinado a permitir la
comunicación entre el usuario y el ordenador, se encargar de gestionar sus
recursos como la gestión de hardware.
T
Tiempo de respuesta: Tiempo que pasa desde que se envía una petición
hasta que se recibe una respuesta.
82
BIBLIOGRAFÍA
1. BERRY,Ian. et al (2013), The Cacti Manual. Recuperado el Agosto de
2014, de
http://www.cacti.net/downloads/docs/html/
2. BENSON, Theophilus. (2010). Unraveling the Complexity of Network
Management. Recuperado el Septiembre de 2014, de
https://www.usenix.org/legacy/events/nsdi09/tech/full_papers/benson/ben
son_html/
3. BMC Remedy IT Service Management (2014). Recuperado el Diciembre
de 2014 de
http://www.bmc.com/solutions/itsm/it-service-management.html
4. GANZABAL, Julián María. (2008). Protocolos de Voz sobre IP.
Recuperado el Agosto del 2014, de
http://www.idris.com.ar/pdf/ART0002%20%20Protocolos%20en%20VoIP.
5. GASKINS, Chris. (2006). Cómo monitorear las amenazas físicas en un
centro de datos. Recuperado el Enero de 2014, de
http://www.fasor.com.sv/whitepapers/whitepapers/Monitoreo/Como_monit
orear_amenazas_fisicas_en_centro_de_datos.pdf
83
6. HAJI, Iqbal. (2013). Development of OSIX – A Peering Point in a Box.
Recuperado el Agosto del 2014, de
http://researcharchive.vuw.ac.nz/xmlui/bitstream/handle/10063/2699/thesi
s.pdf?sequence=2
7. RANCID - Really Awesone New Cisco Config Differ (2010). Recuperado
el Noviembre 2014, de
http://www.shrubbery.net/rancid/
8. STMicroelectronics (2000). L298N datasheet. Recuperado el Febrero de
2015, de
http://www.geeetech.com/Documents/L298N%20datasheet.pdf
9. WEAVER, Gabriel. (March, 2013). Security-Policy Analysis with eXtended
Unix Tools. Recuperado el Septiembre del 2014, de
http://www.cs.dartmouth.edu/reports/TR2013-728.pdf
84
ANEXOS
85
MANUAL DE INSTALACIÓN
Los siguientes documentos son anexos en los cuales se indica la instalación y
configuración detallada de las herramientas a utilizar para el desarrollo del
presente proyecto.
Para cargar información de los sensores y de otros dispositivos usaremos como
base de datos la herramienta MySQL ya que es de licencia libre y es la más
usada para almacenar el tipo de información con el que trabajaremos.
Para procesar la aplicación del lado del servidor se utilizará Apache como
servidor web y del lado del cliente se utiliza cualquier navegador.
Para el análisis y la presentación de los datos en formato de reportes
tradicionales para ordenadores se utilizará la interfaz Cacti.
REQUISITOS DE HARDWARE
Se ha trabajado y se ha probado que el sistema puede convivir en un solo
servidor, bajo una plataforma Debian GNU/Linux 5.0.9 (lenny) con una
arquitectura de 64 bits, con memoria mínima de 2 GB, procesador de mínimo
1.7 GHz y de capacidad de disco de mínimo 40 GB.
86
MANUAL DE INSTALACIÓN DEL S.O. DEBIAN
Debian Linux puede instalarse utilizando distintos mecanismos de instalación,
como DVD, CD, Blu-Ray, memorias USB y diskettes, e incluso directamente
desde la red.
Instalación:
Esta es la primer pantalla que veremos cuando booteamos, seleccionamos
Graphical Install, para acceder a una instalación mucho más intuitiva:
87
Seleccionamos el Idioma:
Y localización, acorde a esta localización se configurará los repositorios de
descarga de actualizaciones
88
Elegimos una distribución adecuada para nuestro teclado
89
Elegimos un nombre para nuestro equipo, se recomienda usar uno que sea
completamente descriptivo y a continuación, escribimos una contraseña para el
usuario root:
A continuación es necesario escribir un usuario de acceso a parte del
administrador y una contraseña para el mismo:
90
El siguiente paso es preparar el disco duro para configurar el tipo de
particionado, seleccionamos manual y seleccionamos el espacio libre.
Seleccionamos el disco a particionar:
91
Se recomienda separar las particiones de manera que en caso de requerir una
depuración de información, se lo haga en una unidad lógica específica:
92
En la siguiente pantalla confirmamos la escritura de los cambios al disco que
vamos a realizar:
Con la configuración correcta confirmada, elegimos continuar:
93
A continuación nos mostrará el resumen de la partición a realizar y continuamos
con el proceso, seleccionamos que no y avanzamos:
94
Elegimos la opción para no instalar complementos desde un CD no y
continuamos:
95
Nos preguntara si deseamos enviar estadísticas del sistema a los
desarrolladores:
En esta pantalla seleccionamos los servicios que esperamos que sean
instalados en conjunto:
96
Por ejemplo, nos pedirá un Workgroup name para la instalación de samba:
Nos preguntara si queremos escribir el grub (cargador de arranque de linux) al
disco, escogemos la opción afirmativa y continuamos:
97
Una vez finalizada la instalación en el reinicio vemos la interfaz de arranque:
98
MANUAL DE INSTALACIÓN DEL ENTORNO LAMP
LAMP es la abreviatura de Linux + Apache2 + PHP5 +MySQL, un ambiente
para escribir scripts, mantener o montar sitios hechos o escritos
en PHP con MySQL sobre un server
Apache.
Instalación Apache2
Configuración para el uso básico de Apache:
Configuración para habilitar el uso de los módulos que hemos instalado
Editamos el archivo /etc/apache2/apache2.conf añadiendo:
Para añadir módulos:
Se pueden encontrar en /usr/lib/apache2/modules/
Por ejemplo: Mod_Rewrite sobrescribe las URL para que sean más amigables
al usuario.
Añadir en /etc/apache2/apache2.conf:
99
Una forma más elegante puede ser, desde la terminal de comandos habilitarlo
con el siguiente comando:
Y después reiniciar Apache:
Instalación/Configuración de PHP5
Configuraciones.
En /etc/php5/apache2/php.ini:
Subir archivos al server [tamaño]:
Uso de la memoria:
Subir archivos, método POST:
100
PHP 5 corre en el sistema como módulo de Apache2, así que, si hacemos
alguna configuración en PHP5 solamente con reiniciar Apache se aplican los
cambios realizados.
Instalación/Configuración de MySQL
En la instalación se solicitará el password para el usuario root de MySQL, por
cuestiones de seguridad, trate de que sea distinto del password de root del
sistema.
Uso básico de MySQL:
Y en la configuración [/etc/mysql/my.cnf, línea 71 aproximadamente] habilitamos
los logs descomentando:
Y luego reiniciando MySQL para que los cambios se apliquen…
Instalación/Configuración de PHPMyAdmin
Y la configuración viene en el archivo config.inc.php, que no está, pero lo
crearemos con el siguiente contenido:
101
102
MANUAL DE INSTALACIÓN SNMP
Vamos a utilizar dos servidores, uno contendrá la parte gerente, mientras que el
otro servidor tendrá el agente, para comprobar su funcionamiento. Podríamos
optar por instalar el agente en la máquina del gestor también, pero mantenerlos
separados hace que sea más fácil de demostrar la funcionalidad proporcionada
por cada componente.
En el primer servidor, actualizaremos la base de datos apt e instalaremos el
componente administrador. Junto con esto, también vamos a descargar otro
paquete snmp-mibs-downloader que contiene algo de información de propiedad
sobre el estándar MIB que nos permiten acceder a la mayor parte del árbol MIB
por nombres:
En nuestro segundo servidor, con el que vamos a estar interactuando se
ejecutará el demonio de snmp, por lo que instalaremos los componentes
necesarios escribiendo:
Una vez que hemos instalado los componentes necesitamos configurarlos.
Configuración del gestor SNMP
Como mencionamos anteriormente, la mayor parte del trabajo ocurre en el
componente agente, por lo que nuestra configuración es en realidad bastante
fácil en esta máquina. Sólo tenemos que modificar un archivo para asegurarnos
de que nuestro cliente puede utilizar los datos MIB adicional que instalamos.
103
Abrimos el archivo /etc/snmp/snmp.conf con un editor de texto usando
privilegios root:
En este archivo, hay algunos comentarios y una sola línea no comentada. Para
permitir que el gestor importe los archivos MIB, simplemente tenemos que des
comentar las líneas mibs : :
Guarde y cierre el archivo cuando haya terminado.
Hemos terminado la configuración en la equipo de gestión, pero todavía
tendremos que utilizar este servidor para ayudarnos a configurar nuestro equipo
agente.
Configuración de la máquina del agente SNMP
Como tenemos un sistema cliente-servidor, el equipo agente no tiene ninguna
de las herramientas externas necesarias para configurar su propio SNMP.
Podemos modificar algunos archivos de configuración que hacer algunos
cambios, pero la mayoría de los cambios que necesitamos se harán mediante la
conexión a nuestro servidor de agente de nuestro servidor de administración.
Para empezar, en nuestro equipo agente, necesitamos abrir el archivo de
configuración del demonio con privilegios sudo:
En el interior, vamos a tener que hacer algunos cambios. Estos se utilizarán
principalmente para arrancar nuestra configuración para que podamos
administrarlo desde nuestro otro servidor.
104
En primer lugar, tenemos que cambiar la directiva agentAddress. En la
actualidad, sólo se establece para permitir conexiones procedentes del equipo
local. Tenemos que comentar la línea actual, y eliminar la línea por debajo, lo
que permite todas las conexiones:
A continuación, vamos a necesitar insertar temporalmente una línea createUser.
Estas directivas no se mantienen normalmente en este archivo, pero la vamos a
sacar de nuevo en un momento, por lo que no importa demasiado.
El usuario que estamos creando se llamará de arranque y será utilizado como
una plantilla en la que podamos crear nuestro primer usuario "real". Los
paquetes SNMP lo hacen a través de un proceso de clonación de las
propiedades del usuario.
Al definir un nuevo usuario, debemos especificar el tipo de autenticación (MD5 o
SHA), debemos suministrar una frase de contraseña que debe tener al menos 8
caracteres. Si planeamos usar el cifrado para la transferencia, también
debemos especificar el protocolo de privacidad (DES o AES) y, opcionalmente,
una contraseña de protocolo de privacidad. Si no se proporciona la frase de
contraseña de protocolo de privacidad, la frase de contraseña de autenticación
se utilizará para el protocolo de privacidad también.
Nuestra línea de creación del usuario se verá así:
Ahora que tenemos un nuevo usuario especifico, tenemos que configurar el
nivel de acceso que este usuario tendrá. Vamos a configurar para esto nuestro
usuario de arranque, y también para el nuevo usuario que vamos a crear,
llamado demo. Vamos a permitir el acceso de lectura utilizando la directiva
rwuser (la alternativa es rouser para el acceso de sólo lectura).
105
Haremos cumplir el uso del cifrado especificando priv después de nuestro
usuario. Si quisiéramos restringir al usuario a una parte específica de la MIB,
podríamos especificar el nivel más alto de OID que el usuario debe tener al final
de la línea de acceso.
Para nuestros propósitos, nuestras líneas serán bastante simples:
Cuando se haya terminado de realizar estos cambios, guardamos y cerramos el
archivo.
Para implementar estos cambios, reiniciamos el servicio snmpd:
Ahora, desde la máquina en que ha instalado el software de gestión, nos
podemos conectar a nuestro servidor agente para crear nuestro usuario
habitual.
Lo haremos con la herramienta snmpusm, que se utiliza para la gestión de
usuarios. Necesitamos la dirección IP del servidor agente para que esto
funcione correctamente.
Estructura general de los comandos SNMP
Cuando se utiliza el conjunto de herramientas incluidas en el paquete snmp (la
suite de software Net-SNMP), podemos notar ciertos patrones en la forma en
que debe llamar a los comandos.
Lo primero que debemos hacer es autenticar con el demonio SNMP que
deseamos comunicarnos. Esto normalmente implica el suministro de un buen
número de piezas de información. Los más comunes son los siguientes:
106
-v VERSION: Este indicador se utiliza para especificar la versión del protocolo
SNMP que desea utilizar. Nosotros vamos a usar v3 en esta guía.
-c COMMUNITY: Este indicador se utiliza si se está utilizando SNMP v1
cadenas de comunidad o de estilo v2 para la autenticación. Puesto que
estamos utilizando la autenticación basada en el usuario de estilo v3, no vamos
a necesitar esto.
-u USER-NAME: Este parámetro se utiliza para especificar el nombre de
usuario que desea autenticar. Para leer o modificar cualquier cosa a través de
SNMP, debemos autenticarnos con un nombre de usuario conocido.
-l LEVEL: Se utiliza para especificar el nivel de seguridad con que nos estamos
conectando. Los valores posibles son noAuthNoPriv sin autenticación y sin
codificación, authNoPriv para la autenticación, pero no encriptación, y authPriv
para la autenticación y el cifrado. El nombre de usuario que se está utilizando
debe estar configurado para operar en el nivel de seguridad que especifique, o
bien la autenticación no tendrá éxito.
-a PROTOCOL: Este parámetro se utiliza para especificar el protocolo de
autenticación que se utiliza. Los valores posibles son MD5 o SHA. Esto debe
coincidir con la información que se ha especificado al crear el usuario.
-x PROTOCOL: Este parámetro se utiliza para especificar el protocolo de
cifrado que se utiliza. Los valores posibles son DES o AES. Esto debe coincidir
con la información que se ha especificado al crear el usuario. Esto es necesario
cuando la especificación de privilegios del usuario ha priv después de que, por
lo que el cifrado obligatorio.
-A PASSPHRASE: Se utiliza para dar la contraseña de autenticación que se ha
especificado al crear el usuario.
-X PASSPHRASE: Esta es la frase de cifrado que se especificó cuando se creó
el usuario. Si ninguno se ha especificado, pero se le dio un algoritmo de cifrado,
se utilizará la contraseña de autenticación. Esto es necesario cuando se da el
107
parámetro -x o siempre de especificación de privilegios de un usuario tiene un
priv después de que, lo que requiere cifrado.
Con esta información, podemos comenzar a construir nuestros comandos.
Teniendo en cuenta cómo hemos creado nuestro usuario arranque, los
comandos que vamos a utilizar con esa cuenta se verá así:
Por ejemplo, desde el servidor de gestión, podemos probar para asegurarnos
de que la cuenta de arranque está disponible escribiendo:
La cadena 1.3.6.1.2.1.1.1.0 es el OID que es responsable para la visualización
de información del sistema. Será básicamente devolver la salida de uname -a
en el sistema remoto.
Ahora que hemos comprobado que podemos autenticar correctamente al
servidor que ejecuta el daemon SNMP, podemos continuar a crear nuestra
cuenta de usuario normal.
Configuración de la cuenta de usuario
Aunque hemos indicado los privilegios de la cuenta de usuario de demostración
en nuestro archivo snmpd.conf, no hemos realmente creado este usuario
todavía. Vamos a utilizar el usuario arranque como plantilla para el nuevo
usuario.
En el servidor de gestión, podemos crear el usuario de la plantilla con la función
snmpusm y la siguiente sintaxis general:
108
Por lo tanto, con el uso de lo que sabemos acerca de las banderas de
autenticación que necesitamos para pasar, y el aprovechamiento de la cuenta
de usuario que ya tenemos (de arranque), podemos hacer que un usuario se
adapte a los privilegios del usuario que ya hemos definido (demo).
El comando se verá así:
Se debe recibir el siguiente mensaje:
Ahora tenemos un usuario llamado demo completamente funcional en nuestro
servidor remoto. Sin embargo, se sigue utilizando la misma información de
autenticación como la cuenta de bootstrap. Debemos cambiar la contraseña a
por otra. Esta vez, vamos a utilizar la cuenta demo para autenticar. Hay que
recordar, las contraseñas deben tener al menos 8 caracteres de longitud:
Debemos obtener el siguiente resultado:
Podemos probar nuestras nuevas credenciales y contraseña haciendo la
consulta al servidor remoto sobre el tiempo que el servicio SNMP ha estado
funcionando. Usaremos el comando snmpget para obtener un único valor de la
otra máquina.
Esta vez, vamos a aprovechar las definiciones MIB adicionales que hemos
descargado. Podemos utilizar estas para pedir el valor por su nombre en lugar
de la identificación numérica OID.
109
Debemos obtener un valor que representa la última vez que el demonio SNMP
remoto se ha reiniciado:
110
MANUAL DE USUARIO
Cacti es un sistema de monitorización con el que podemos tener controlados
casi en tiempo real los dispositivos que soportan los servicios que presta
nuestra red (routers, conmutadores ó servidores, tráfico de interfaces, cargas,
cpu, temperaturas, etc.). Es un potente software que nos permite controlar en
todo momento el estado de nuestra red.
Este sistema de monitorización contiene un recolector de datos excelente, un
sistema avanzado de creación de plantillas y gráficos y una completa interfaz de
gestión de usuarios.
La aplicación está construida en php, y utiliza MySql para el almacenamiento de
información sobre los gráficos y datos recogidos. El protocolo utilizado para la
comunicación con los distintos equipos es SNMP, el cual facilita el intercambio
de información de administración entre dispositivos de red y permite a los
administradores supervisar el uso de la red, buscar y resolver sus problemas, y
planificar su crecimiento.
Visualización/creación de máquinas y gráficas
Una de las partes más útiles de la herramienta Cacti es la monitorización a
través de gráficas. Pero antes de poder crearlas, necesitamos definir qué
dispositivos de nuestra red vamos a gestionar.
Nos conectamos al servidor Cacti y nos registramos. Actualmente hay definidos
dos usuarios con diferentes permisos: “admin” y “guest”. Para realizar muchas
de las tareas aquí descritas será necesario registrarse con el usuario “admin”:
http://IP_CACTI/index.php
111
Pantalla de Inicio de Sesión:
Al introducir el usuario y contraseña facilitados, accedemos a la pantalla
principal de Cacti, desde la cual podemos ver todos los contenidos de la
aplicación de gestión de dispositivos de red.
112
En los siguientes apartados se explicará con detalle cada una de estas
secciones.
Máquinas visualización
Para ver los elementos pertenecientes a nuestra red vamos a la pestaña
Console Management Devices y nos aparecerá una pantalla como esta:
Para ver los detalles (IP, community, descripción, etc.) bastará con pinchar en la
máquina correspondiente.
Nuevos dispositivos
Si en un futuro se agrega algún equipo nuevo a la red habrá que pinchar en “Add” y
nos aparecerá una pantalla como esta, donde están marcados los parámetros más
importantes:
113
Será en ese momento en el que se nos agregará dicho equipo a la lista inicial que
vemos al pinchar en “Devices”, como se ha comentado en el apartado anterior.
Gráficas visualización
Como comentamos en la Introducción, Cacti nos permite visualizar gráficas asociadas
a cada equipo. Consideramos que las más importantes para monitorizar la red son las
siguientes:
- Tráfico de Red
- Uso de la CPU
- Uso de la memoria
- Temperatura
Para visualizar las gráficas asociadas a los equipos que componen la red nos vamos a
la pestaña “graphs” y nos encontramos con un árbol desplegable con una rama por
cada equipo (o host). Pinchando encima visualizamos las gráficas correspondientes.
114
A través del menú lateral izquierdo podemos navegar por el árbol de dispositivos, y
podremos consultar todas las gráficas definidas para ellos.
Si pinchamos alguna de las gráficas obtendremos la representación de los valores en
la última hora, el último día, semana, mes y año. En el caso del tráfico de red,
obtendríamos algo como esto:
115
Nuevas gráficas
Para crear nuevos gráficos asociados a nuestros equipos se procede de la
siguiente manera: pinchamos en la pestaña Console Create New Graphs
y elegimos en el desplegable de “Host” qué equipo queremos elegir:
116
Saldrá una lista con las gráficas disponibles para ese dispositivo. Hay que tener en
cuenta que dependiendo de la marca y modelo del dispositivo, se podrán monitorizar
unos elementos u otros. Marcamos la casilla de la derecha de las gráficas que
queramos añadir. El proceso finaliza pinchando en Create:
117
Si necesitamos modificar algún valor de la gráfica como puede ser el título, nos
vamos a “Console Management Graph Management” y aparecerá incluida
en la lista.
118
Podemos tener una lista con todas las gráficas juntas (“Any”) o por equipo
haciendo uso del desplegable “Host”.
Pinchando en la gráfica de interés la podemos visualizar y modificar:
119
Estas gráficas se incluyen automáticamente en la rama correspondiente del árbol de
gráficas al cual podemos acceder haciendo uso del menú lateral izquierdo como se
explica a continuación.
Visualización del árbol y modificación de ramas
En Cacti, la manera de organizar las gráficas es a través de árboles. Cada árbol
a su vez puede tener ramas, que pueden ser o bien “hosts” o bien una “gráfica”.
Si elegimos un host, todas sus gráficas asociadas colgarán de esa rama. Sin
embargo, al elegir una gráfica sólo se mostrará ella misma. Si tenemos un host
con muchas gráficas, es preferible crear siempre ramas de “hosts”. Podemos
crear tantos árboles como ramas sean necesarias para conseguir tener la
organización que nos convenga. Si hemos creado una nueva máquina y le
hemos asociado gráficas, lo podremos incluir en cualquiera de los árboles como
una nueva rama. Para ello, nos vamos a “Console Management Graph
Trees” y podremos visualizar los árboles existentes. En la configuración inicial
de la sede de trabajo, se han creado dos ramas: una de servidores, que
120
contiene gráficas del propio servidor web, y otra de electrónica de red, con
gráficas de los dispositivos. Sin pinchamos en “Electrónica de red”, aparece una
lista con las actuales ramas.
Si queremos agregar una más, por ejemplo si hemos creado un dispositivo
nuevo, pinchamos en Add y rellenamos el formulario. En “Tree Item Type”
elegimos “Host” y debajo el host (ó máquina) en cuestión. Finalizamos el
proceso pinchando en Create. Podremos comprobar que se ha incluido en el
árbol correspondiente pinchando en la pestaña superior “graphs” y navegando
por las ramas.
Alertas
Como comentamos en la introducción, Cacti nos da la opción de enviar alertas
a nuestra cuenta de correo en caso de que ocurra alguna irregularidad en
nuestros equipos. Nos vamos a la pestaña Console Configuration Settings
y pinchamos en la pestaña Alerting/Thold.
121
Aquí podemos configurar las opciones de alerta tales como el mensaje que queremos
que nos llegue, desde qué cuenta, con qué asunto, etc. La configuración del servidor
de correo por ejemplo se hace desde la pestaña “Mail/DNS” a la derecha de la pestaña
presente. Si además hemos marcado la opción “Dead Hosts Notifications” en la
pestaña anterior, recibiremos en la cuenta configurada un correo electrónico cada vez
que se pierda la conectividad con un dispositivo.
122
Cambiar/agregar usuarios y password
Si queremos cambiar el nombre o la contraseña del usuario que está creado por
defecto hay que ir a la pestaña de Console Utilities User Management
donde nos aparecerán los usuarios definidos.
123
Copia de seguridad en cacti (backup)
El sistema realiza automáticamente y a diario una copia de seguridad (ó
backup) de su configuración completa y lo guarda comprimido en
/var/www/backups.
Por seguridad, es conveniente guardar una copia de estos ficheros en un
servidor remoto de almacenamiento de copias de seguridad. Se puede sacar
dicha copia de manera automática a través de algún script o de forma manual, a
través de webmin.
Proceso de Restauración de la copia
Tenemos la copia de seguridad en un fichero comprimido en /var/www/backups
en la maquina con la instalación de Cacti a restaurar. Nos vamos al directorio
donde tengamos instalado el Cacti (/var/www/html/cacti) y descomprimimos la
copia de seguridad.
Este proceso reescribirá cualquier configuración previa:
tar -xzvf /var/www/backups/cacti-backup.tar.gz
124
Importamos la base de datos sql y reiniciamos los servicios:
mysql cacti < /var/www/html/cacti-backup.sql
mysql syslog < /var/www/html/syslog.sql
service httpd restart
service mysqld restart
