XXX
XXX WARNING: old character encoding and/or character set
XXX
RRDTUTORIAL.ES(1)                   RRDtool                  RRDTUTORIAL.ES(1)



NNAAMMEE
       rrdtutorial - Tutorial sobre RRDtool por Alex van den Bogaerdt (Tra-
       ducido al castellano por Jes?s Couto Fandi?o)

DDEESSCCRRIIPPTTIIOONN
       RRDtool es un programa escrito por Tobias Oetiker con la colaboraci?n
       de muchas personas en diversas partes del mundo. Alex van den Bogaerdt
       escribi? este documento para ayudarte a entender que es RRDtool y que
       es lo que puede hacer por ti.

       La documentaci?n que viene con RRDtool puede ser demasiado t?cnica para
       algunos. Este tutorial existe para ayudarte a entender las funciones
       b?sicas de RRdtool. Debe servirte de preparaci?n para leer la docu-
       mentaci?n, y adem?s explica algunas ideas generales sobre estad?stica,
       con un enfoque particular hacia las redes.

TTUUTTOORRIIAALL
       IImmppoorrttaannttee

       ?Por favor, no te adelantes en la lectura de este documento! Esta
       primera parte explica los fundamentos b?sicos. Puede ser aburrida, pero
       si te saltas los fundamentos, los ejemplos no te van a tener mucho sen-
       tido.

       ??QQuu?? eess RRRRDDttooooll??

       RRDtool significa "herramienta de bases de datos en round robin".
       "Round robin" es una t?cnica que implica un n?mero fijo de datos, y un
       apuntador al elemento m?s reciente. Piensa en un circulo con unos cuan-
       tos puntos dibujados alrededor del borde; estos puntos son los lugares
       donde se pueden guardar los datos. Dibuja ahora una flecha desde el
       centro del c?rculo a uno de los puntos; este es el apuntador.  Cuando
       se lee o escribe el dato actualmente apuntado, la flecha se mueve al
       pr?ximo elemento. Como estamos en un c?rculo, no hay ni principio ni
       fin; siempre puedes seguir, eternamente. Al cabo de un tiempo ya se
       habr?n usado todas las posiciones disponibles y el proceso empieza a
       reutilizar las antiguas. De esta forma, la base de datos no crece en
       tama?o y, por lo tanto, no requiere ning?n mantenimiento.  RRDtool tra-
       baja con estas bases de datos en "round-robin", guardando y recuperando
       datos de ellas.

       ??QQuu?? ddaattooss ppuueeddeenn gguuaarrddaarrssee eenn uunnaa RRRRDD??

       Lo que se te ocurra. Debes poder medir alg?n valor dado en distintos
       momentos en el tiempo y proveer a RRDtool de estos valores. Si puedes
       hacer esto, RRDtool puede guardar los datos. Los valores tienen que ser
       num?ricos, pero no necesariamente enteros, como en MRTG.

       Muchos ejemplos mencionan SNMP, que es el acr?nimo de "Simple Network
       Management Protocol" (Protocolo Simple de Administraci?n de Redes). Lo
       de "simple" se refiere al protocolo - no se supone que sea f?cil admin-
       istrar o monitorizar una red. Cuando hayas terminado con este docu-
       mento, deber?s saber lo suficiente para entender cuando oigas a otros
       hablar sobre SNMP. Por ahora, simplemente considera a SNMP como una
       forma de preguntarle a los dispositivos por los valores de ciertos con-
       tadores que mantienen. Son estos valores de estos contadores los que
       vamos a almacenar en la RRD.

       ??QQuu?? ppuueeddoo hhaacceerr ccoonn eessttaa hheerrrraammiieennttaa??

       RRDtool se deriva de MRTG (Multi Router Traffic Grapher, Graficador De
       Tr?fico de M?ltiples Enrutadores).  MRTG empez? como un peque?o script
       para poder graficar el uso de una conexi?n a la Internet. Luego evolu-
       cion?, permitiendo graficar otras fuentes de datos, como temperatura,
       velocidad, voltajes, cantidad de p?ginas impresas, etc... Lo m?s proba-
       ble es que empieces a usar RRDtool para guardar y procesar datos con-
       seguidos a trav?s de SNMP, y que los datos sean el n?mero de bytes (o
       bits) transferidos desde y hacia una red u ordenador. RRDtool te per-
       mite crear una base de datos, guardar los datos en ellas, recuperarlos
       y crear gr?ficos en formato GIF o PNG, para mostrarlos en un navegador
       web. Esas im?genes dependen de los datos que hayas guardado y pueden,
       por ejemplo, ser un sumario del promedio de uso de la red, o los picos
       de tr?fico que ocurrieron.  Tambi?n lo puedes usar para mostrar el
       nivel de las mareas, la radiaci?n solar, el consumo de electricidad, el
       n?mero de visitantes en una exposici?n en un momento dado, los niveles
       de ruido cerca del aeropuerto, la temperatura en tu lugar de vacaciones
       favorito, o en la nevera, o cualquier otra cosa que te puedas imaginar,
       mientras tengas alg?n sensor con el cual medir los datos y seas capaz
       de pasarle los n?meros a RRDtool.

       ??YY ssii aa??nn tteennggoo pprroobblleemmaass ddeessppuu??ss ddee lleeeerr eessttee ddooccuummeennttoo??

       Lo primero, ?l?elo otra vez!. Puede que te hayas perdido de algo.  Si
       no puedes compilar el c?digo fuente y usas un sistema operativo bas-
       tante com?n, casi seguro que no es la culpa de RRDtool.  Probablemente
       consigas versiones pre-compiladas por la Internet. Si provienen de una
       fuente confiable, ?salas. Si, por otro lado, el programa funciona, pero
       no te da los resultados que tu esperabas, puede ser un problema con la
       configuraci?n; rev?sala y comp?rala con los ejemplos.

       Hay una lista de correo electr?nico y una archivo de la misma. Lee la
       lista durante unas cuantas semanas, y busca en el archivo. Es descort?s
       hacer una pregunta sin haber revisado el archivo; ?puede que tu prob-
       lema ya haya sido resuelto antes! Normalmente ocurre as? en todas las
       listas de correo, no s?lo esta. Examina la documentaci?n que vino con
       RRDtool para ver donde est? el archivo y como usarlo.

       Te sugiero que te tomes un momento y te subscribas a la lista ahora
       mismo, enviando un mensaje a rrd-users-request@list.ee.ethz.ch con
       t?tulo "subscribe". Si eventualmente deseas salirte de la lista, env?a
       otro correo a la misma direcci?n, con t?tulo "unsubscribe".

       ??CC??mmoo mmee vvaass aa aayyuuddaarr??

       D?ndote descripciones y ejemplos detallados. Asumimos que el seguir las
       instrucciones en el orden en que se presentan aqu? te dar? suficiente
       conocimiento  de RRDtool como para que experimentes por tu cuenta. Si
       no funciona a la primera, puede que te hallas saltado algo; siguiendo
       los ejemplos obtendr?s algo de experiencia pr?ctica y, lo que es m?s
       importante, un poco de informaci?n sobre como funciona el programa.

       Necesitar?s saber algo sobre n?meros hexadecimales. Si no, empieza por
       leer "bin_dec_hex" antes de continuar.

       TTuu pprriimmeerraa bbaassee ddee ddaattooss eenn rroouunndd--rroobbiinn

       En mi opini?n, la mejor forma de aprender algo es haci?ndolo. ?Por qu?
       no empezamos ya? Vamos a crear una base de datos, poner unos cuantos
       valores en ella y extraerlos despu?s. La salida que obtengas debe ser
       igual a la que aparece en este documento.

       Empezaremos con algo f?cil, comparando un coche con un enrutador, o por
       decirlo de otra forma, comparando kil?metros con bits y bytes. A
       nosotros nos da lo mismo; son unos n?meros obtenidos en un espacio de
       tiempo.

       Asumamos que tenemos un dispositivo que transfiere bytes desde y hacia
       la Internet. Este dispositivo tiene un contador que empieza en 0 al
       encenderse y se incrementa con cada byte transferido. Este contador
       tiene un valor m?ximo; si ese valor se alcanza y se cuenta un byte m?s,
       el contador vuelve a empezar desde cero. Esto es exactamente lo mismo
       que pasa con muchos contadores, como el cuentakil?metros del coche. En
       muchas de las disertaciones sobre redes se habla de bits por segundo,
       as? que empezaremos por acostumbrarnos a esto. Asumamos que un byte son
       8 bits y empecemos a pensar en bits y no en bytes. ?El contador, sin
       embargo, sigue contando en bytes! En el mundo SNMP, la mayor?a de los
       contadores tienen una longitud de 32 bits. Esto significa que pueden
       contar desde 0 hasta 4294967295. Usaremos estos valores en los ejemp-
       los. El dispositivo, cuando le preguntamos, retorna el valor actual del
       contador. Como sabemos el tiempo transcurrido desde la ?ltima vez que
       le preguntamos, sabemos cuantos bytes se han transferido "***en prome-
       dio***" por segundo. Esto no es muy dif?cil de calcular; primero en
       palabras, luego en operaciones:

       1.  Toma el valor actual del contador y r?stale el valor anterior

       2.  Haz lo mismo con la fecha

       3.  Divide el resultado del paso (1) por el resultado del paso (2).  El
           resultado es la cantidad de bytes por segundo. Si lo multiplicas
           por ocho obtienes la cantidad de bits por segundo

         bps = (contador_actual - contador_anterior) / (fecha_actual - fecha_anterior) * 8

       Para algunos ser? de ayuda traducir esto a un ejemplo automotor.  No
       prueben estas velocidades en la pr?ctica, y si lo hacen, no me echen la
       culpa por los resultados.

       Usaremos las siguientes abreviaturas:

        M:    metros
        KM:   kil?metros (= 1000 metros).
        H:    horas
        S:    segundos
        KM/H: kil?metros por hora
        M/S:  metros por segundo

       Vas conduciendo un coche. A las 12:05, miras el contador en el salpi-
       cadero y ves que el coche ha recorrido 12345 KM. A las 12:10 vuelves a
       mirar otra vez, y dice 12357 KM. Quiere decir, que has recorrido 12 KM
       en cinco minutos. Un cient?fico convertir?a esto en metros por segun-
       dos; esto es bastante parecido al problema de pasar de bytes transferi-
       dos en 5 minutos a bits por segundo.

       Viajamos 12 kil?metros, que son 12000 metros. Tardamos 5 minutos, o sea
       300 segundos. Nuestra velocidad es 12000M / 300S igual a 40 M/S.

       Tambi?n podemos calcular la velocidad en KM/H: 12 veces 5 minutos es
       una hora, as? que multiplicando los 12 KM por 12 obtenemos 144 KM/H. No
       intentes esto en casa, o por donde vivo :-)

       Recuerda que estos n?meros son tan s?lo promedios. No hay forma de
       deducir, viendo s?lo los n?meros, si fuiste a una velocidad constante.
       Hay un ejemplo m?s adelante en el tutorial que explica esto.

       Espero que entiendas que no hay diferencia entre calcular la velocidad
       en M/S o bps; s?lo la forma en que recogemos los datos es distinta.
       Inclusive, la K de kilo en este caso es exactamente la misma, ya que en
       redes k es 1000

       Ahora vamos a crear una base de datos en la que guardar todos estos
       interesantes valores. El m?todo a usar para arrancar el programa puede
       variar de un sistema de operaci?n a otro, pero asumamos que lo puedes
       resolver tu mismo en caso que se diferente en el sistema que usas.
       Aseg?rate de no sobreescribir ning?n archivo en tu sistema al ejecu-
       tarlo y escribe todo como una sola l?nea (tuve que partirlo para que
       fuera legible), salt?ndote todos los caracteres '\'

          rrdtool create test.rrd             \
                   --start 920804400          \
                   DS:speed:COUNTER:600:U:U   \
                   RRA:AVERAGE:0.5:1:24       \
                   RRA:AVERAGE:0.5:6:10

       (o sea, escribe: "rrdtool create test.rrd --start 920804400 DS ...")

       ??QQuu?? hheemmooss ccrreeaaddoo??

       Hemos creado una base de datos en round robin llamada test (test.rrd),
       que empieza desde el mediod?a del d?a en que empec? a escribir este
       documento (7 de marzo de 1999). En ella se guarda una fuente de datos
       (DS), llamada "speed", que se lee de un contador. En la misma base de
       datos se guardan dos archivos en round robin (RRAs), uno promedia los
       datos cada vez que se leen (o sea, no hay nada que promediar), y
       mantiene 24 muestras (24 por 5 minutos = 2 horas de muestras). El otro
       promedia 6 muestras (media hora), y guarda 10 de estos promedios (o
       sea, 5 horas). Las opciones restantes las veremos m?s adelante.

       RRDtool usa un formato de "fecha" especial que viene del mundo de UNIX.
       Estas "fechas" son el n?mero de segundos que han pasado desde el
       primero de enero de 1970, zona UTC. Este n?mero de segundos se con-
       vierte luego en la fecha local, por lo que varia seg?n la franja
       horaria.

       Lo m?s probable es que tu no vivas en la misma parte del mundo que yo,
       por lo que tu franja horaria ser? diferente. En los ejemplos, cuando
       mencione horas, puede que no sean las mismas para ti; esto no afecta
       mucho los resultados, s?lo tienes que corregir las horas mientras lees.
       Por ejemplo, las 12:05 para m? son las 11:05 para los amigos en la Gran
       Breta?a.

       Ahora tenemos que llenar nuestra base de datos con valores. Vamos a
       suponer que le?mos estos datos:

        12:05  12345 KM
        12:10  12357 KM
        12:15  12363 KM
        12:20  12363 KM
        12:25  12363 KM
        12:30  12373 KM
        12:35  12383 KM
        12:40  12393 KM
        12:45  12399 KM
        12:50  12405 KM
        12:55  12411 KM
        13:00  12415 KM
        13:05  12420 KM
        13:10  12422 KM
        13:15  12423 KM

       Llenaremos la base de datos as?:

        rrdtool update test.rrd 920804700:12345 920805000:12357 920805300:12363
        rrdtool update test.rrd 920805600:12363 920805900:12363 920806200:12373
        rrdtool update test.rrd 920806500:12383 920806800:12393 920807100:12399
        rrdtool update test.rrd 920807400:12405 920807700:12411 920808000:12415
        rrdtool update test.rrd 920808300:12420 920808600:12422 920808900:12423

       Lo que significa: actualiza nuestra base de datos test con los sigu-
       ientes valores:

        fecha 920804700, valor 12345
        fecha 920805000, valor 12357

        etc?tera.

       Como ves, pueden introducirse m?s de un valor en la base de datos por
       ejecuci?n del comando. Yo los agrupo de tres en tres para hacerlo legi-
       ble, pero en realidad el m?ximo depende del sistema de operaci?n.

       Ahora podemos recuperar los datos usando ''rrdtool fetch'':

        rrdtool fetch test.rrd AVERAGE --start 920804400 --end 920809200

       Debes obtener esto como salida:

                           speed

        920804400:        NaN
        920804700:        NaN
        920805000: 4.0000000000e-02
        920805300: 2.0000000000e-02
        920805600: 0.0000000000e+00
        920805900: 0.0000000000e+00
        920806200: 3.3333333333e-02
        920806500: 3.3333333333e-02
        920806800: 3.3333333333e-02
        920807100: 2.0000000000e-02
        920807400: 2.0000000000e-02
        920807700: 2.0000000000e-02
        920808000: 1.3333333333e-02
        920808300: 1.6666666667e-02
        920808600: 6.6666666667e-03
        920808900: 3.3333333333e-03
        920809200:        NaN

       Si no, hay algo mal. Probablemente tu sistema de operaci?n muestre
       ''NaN'' de otra forma; representa "Not a Number", o sea "No es un
       n?mero". Si aparece ''U'' o ''UNKN'' o algo parecido, es lo mismo. Si
       hay alguna otra diferencia, probablemente te equivocaste al introducir
       alg?n P valor (asumiendo que mi tutorial est? bien, por supuesto :-).
       En ese caso, borra la base de datos y prueba de nuevo.

       Lo que representa exactamente esta salida lo vamos m?s adelante en el
       tutorial.

       HHoorraa ddee hhaacceerr aallgguunnooss ggrr??ffiiccooss

       Prueba este comando:

        rrdtool graph speed.gif                                 \
                --start 920804400 --end 920808000               \
                DEF:myspeed=test.rrd:speed:AVERAGE              \
                LINE2:myspeed#FF0000

       Este comando crea speed.gif, un gr?fico de los datos desde las 12:00
       hasta las 13:00. Contiene una definici?n de la variable myspeed y
       define el color como rojo. Notar?s que el gr?fico no comienza exacta-
       mente a las 12:00 sino a las 12:05, y es porque no tenemos datos sufi-
       cientes como para calcular el promedio de velocidad antes de ese
       momento. Esto s?lo ocurre en caso de que se pierdan alg?n muestreo, lo
       que esperamos que no debe ocurrir muy a menudo.

       Si ha funcionado, ?felicitaciones!. Si no, revisa qu? puede estar mal.

       La definici?n de colores se construye a partir del rojo, verde y azul.
       Especificas cuanto de cada uno de estos componentes vas a usar en hex-
       adecimal: 00 significa "nada de este color" y FF significa "este color
       a m?xima intensidad". El "color" blanco es la mezcla del rojo, verde y
       azul a toda intensidad: FFFFFF; el negro es la ausencia de todos los
       colores: 000000.

          rojo    #FF0000
          verde   #00FF00
          azul    #0000FF
          violeta #FF00FF     (mezcla de rojo y azul)
          gris    #555555     (un tercio de cada uno de los colores)

       El archivo GIF que acabas de crear puede verse con tu visor de archivos
       de imagen favorito. Los navegadores lo mostrar?n usando la URL
       ''file://el/camino/de/directorios/hasta/speed.gif''

       GGrr??ffiiccooss ccoonn uunn ppooccoo ddee mmaatteemm??ttiiccaa

       Cuando veas la imagen, notar?s que el eje horizontal tiene unas etique-
       tas marcando las 12:10, 12:20, 12:30, 12:40 y 12:50. Los otros dos
       momentos (12:00 y 13:00) no se pueden mostrar bien por falta de datos,
       as? que el programa se los salta. El eje vertical muestra el rango de
       los valores que entramos. Introdujimos los kil?metros y luego dividimos
       entre 300 segundos, por lo que obtuvimos valores bastante bajos. Para
       ser exactos, el primer valor, 12 (12357-12345), dividido entre 300 da
       0.04, lo que RRDtool muestra como ''40m'', o sea ''40/1000''. ?La
       ''m''' no tiene nada que ver con metros, kil?metros o mil?metros!.
       RRDtool no sabe nada de unidades, el s?lo trabaja con n?meros, no con
       metros.

       Donde nos equivocamos fue en que debimos medir en metros. As?,
       (12357000-12345000)/300 = 12000/300 = 40.

       Vamos a corregirlo. Podr?amos recrear la base de datos con los valores
       correctos, pero hay una forma mejor: ?haciendo los c?lculos mientras
       creamos el archivo gif!

          rrdtool graph speed2.gif                           \
             --start 920804400 --end 920808000               \
             --vertical-label m/s                            \
             DEF:myspeed=test.rrd:speed:AVERAGE              \
             CDEF:realspeed=myspeed,1000,*                   \
             LINE2:realspeed#FF0000

       Cuando veas esta imagen, notar?s que la ''m'' ha desaparecido, y ahora
       tienes los resultados correctos. Adem?s hemos a?adido una etiqueta a la
       imagen. Apartando esto, el archivo GIF es el mismo.

       Las operaciones est?n en la secci?n del CDEF y est?n escritas en
       Notaci?n Polaca Inversa (Reverse Polish Notation o ''RPN''). En pal-
       abras, dice: "toma la fuente de datos myspeed y el numero 1000, y mul-
       tipl?calos". No te molestes en meterte con RPN todav?a, la veremos con
       m?s detalle m?s adelante. Adem?s, puede que quieras leer mi tutorial
       sobre los CDEF y el tutorial de Steve Rader sobre RPN, pero primero
       terminemos con este.

       ?Un momento! Si podemos multiplicar los valores por mil, entonces,
       ?tambi?n deber?a ser posible el mostrar la velocidad en kil?metros por
       hora usando los mismos datos!

       Para cambiar el valor que medimos en metros por segundo, calculamos los
       metros por hora (valor * 3600) y dividimos entre 1000 para sacar los
       kil?metros por hora. Todo junto hace valor * (3600/1000) == valor *
       3.6.

       Como en nuestra base de datos cometimos un error guardando los valores
       en kil?metros, debemos compensar por ello, multiplicando por 100, por
       lo que al aplicar esta correcci?n nos queda valor * 3600.

       Ahora vamos a crear este gif, agre?ndole un poco m?s de magia...

          rrdtool graph speed3.gif                           \
             --start 920804400 --end 920808000               \
             --vertical-label km/h                           \
             DEF:myspeed=test.rrd:speed:AVERAGE              \
             "CDEF:kmh=myspeed,3600,*"                       \
             CDEF:fast=kmh,100,GT,kmh,0,IF                   \
             CDEF:good=kmh,100,GT,0,kmh,IF                   \
             HRULE:100#0000FF:"Maximum allowed"              \
             AREA:good#00FF00:"Good speed"                   \
             AREA:fast#FF0000:"Too fast"

       Esto luce mucho mejor. La velocidad en KM/H, y adem?s tenemos una l?nea
       extra mostrando la velocidad m?xima permitida (en el camino por donde
       conduzco). Tambi?n le cambie los colores de la velocidad, y ahora paso
       de ser una l?nea a un ?rea.

       Los c?lculos son m?s complejos ahora. Para calcular la velocidad
       "aceptable":

          Verifica si la velocidad en kmh es mayor que 100     ( kmh,100 ) GT
          Si es as?, retorna 0, si no, retorna la velocidad    ((( kmh,100 ) GT ), 0, kmh) IF

       Para calcular la parte de velocidad "excesiva":

          Verifica si la velocidad en kmh es mayor que 100     ( kmh,100 ) GT
          Si es as?, retorna la velocidad, si no, retorna 0    ((( kmh,100) GT ), kmh, 0) IF

       MMaaggiiaa ggrr??ffiiccaa

       Me gusta creer que virtualmente no hay limites para lo que RRDtool
       puede hacer con los datos. No voy a explicarlo en detalle, pero mira
       este GIF:

          rrdtool graph speed4.gif                           \
             --start 920804400 --end 920808000               \
             --vertical-label km/h                           \
             DEF:myspeed=test.rrd:speed:AVERAGE              \
             "CDEF:kmh=myspeed,3600,*"                       \
             CDEF:fast=kmh,100,GT,100,0,IF                   \
             CDEF:over=kmh,100,GT,kmh,100,-,0,IF             \
             CDEF:good=kmh,100,GT,0,kmh,IF                   \
             HRULE:100#0000FF:"Maximum allowed"              \
             AREA:good#00FF00:"Good speed"                   \
             AREA:fast#550000:"Too fast"                     \
             STACK:over#FF0000:"Over speed"

       Vamos a crear una p?gina HTML simple para ver los tres archivos GIF:

          <HTML><HEAD><TITLE>Velocidad</TITLE></HEAD><BODY>
          <IMG src="speed2.gif" alt="Speed in meters per second">
          <BR>
          <IMG src="speed3.gif" alt="Speed in kilometers per hour">
          <BR>
          <IMG src="speed4.gif" alt="Traveled too fast?">
          </BODY></HTML>

       Gu?rdalo como ''speed.html'' o algo parecido, y exam?nalo con un naveg-
       ador.

       Ahora, todo lo que tienes que hacer es medir los datos regularmente y
       actualizar la base de datos. Cuando quieras verlos, vuelve a crear los
       archivos GIF y aseg?rate que se carguen de nuevo en tu navegador (Nota:
       presionar el bot?n de "refrescar" puede no ser suficiente; en particu-
       lar, Netscape tiene un problema al respecto, por lo que necesitaras
       darle al bot?n mientras presionas la tecla de may?sculas.

       AAccttuuaalliizzaacciioonneess ddee vveerrddaadd

       Ya hemos usado el comando ''update''; vimos que recibia uno o m?s
       par?metros en el formato: ''<fecha>:<valor>''. Para facilitarte las
       cosas, puedes obtener la fecha actual colocando ''N'' en la fecha.
       Tambi?n podr?as usar la funci?n ''time'' de Perl para obtenerla. El
       ejemplo m?s corto de todo el tutorial :)

          perl -e 'print time, "\n" '

       Ahora, la forma de poner a correr un programa a intervalos regulares de
       tiempo depende del sistema de operaci?n. La actualizaci?n, en
       pseudo-c?digo, ser?a:

          Toma el valor, col?calo en la variable "$speed"
          rrdtool update speed.rrd N:$speed

       (Pero no lo hagas sobre nuestra base de datos de pruebas, que a?n la
       vamos a usar en otros ejemplos.

       Eso es todo. Ejecutando este script cada 5 minutos, lo ?nico que tienes
       que hacer para ver los gr?ficos actuales es correr los ejemplos anteri-
       ores, que tambi?n puedes poner en un script. Luego de correrlo, basta
       con cargar index.html

       UUnnaass ppaallaabbrraass ssoobbrree SSNNMMPP

       Me imagino que muy pocas personas ser?n capaces de obtener en su orde-
       nador datos reales de su coche cada 5 minutos; los dem?s nos tendremos
       que conformar con alg?n otro contador. Puedes, por ejemplo, medir la
       cantidad de p?ginas que ha hecho una impresora, cuanto caf? has hecho
       con la cafetera, el medidor del consumo de electricidad, o cualquier
       otra cosa. Cualquier contador incremental puede monitorizarse y grafi-
       carse con lo que has aprendido hasta ahora. M?s adelante, veremos
       tambi?n como monitorizar otro tipo de valores, como la temperatura. La
       mayor?a usaremos alguna vez un contador que lleve la cuenta de cuantos
       octetos (bytes) a transferido un dispositivo de red, as? que vamos a
       ver como hacer esto. Empezaremos describiendo como recoger los datos.
       Hay quien dir? que hay herramientas que pueden recoger estos datos por
       ti. ?Es cierto! Pero, creo que es importante darse cuenta de que no son
       necesarias. Cuando tienes que determinar porqu? algo no funciona, nece-
       sitas saber c?mo funciona en primer lugar.

       Una herramienta que mencionamos brevemente al principio del documento
       es SNMP. SNMP es una forma de comunicarse con tus equipos.  La her-
       ramienta particular que voy a usar m?s adelante se llama ''snmpget'', y
       funciona as?:

          snmpget dispositivo clave OID

       En "dispositivo" colocas el nombre o direcci?n IP del equipo a monitor-
       izar. En clave, colocas la "cadena de caracteres de la comunidad de
       lectura", como se le denomina en el mundillo SNMP.  Muchos dispositivos
       aceptar?n "public" como cadena por defecto, pero por razones de pri-
       vacidad y seguridad esta clave puede estar deshabilitada. Consulta la
       documentaci?n correspondiente al dispositivo o programa.

       Luego esta el tercer par?metro, llamado OID (Object IDentifier, identi-
       ficador de objeto).

       Al principio, cuando empiezas a aprender sobre SNMP, parece muy
       confuso. No lo es tanto cuando le hechas una ojeada a los ''MIB'' (Man-
       ager Information Base, o Base de Informaci?n Administrativa). Es un
       ?rbol invertido que describe los datos, empezando en un nodo ra?z desde
       el que parten varias ramas.  Cada rama termina en otro nodo y puede
       abrir nuevas sub-ramas. Cada rama tiene un nombre, y forman un camino
       que nos lleva hasta el fondo del ?rbol. En este ejemplo, las ramas que
       vamos a tomar se llaman iso, org, dod, internet, mgmt y mib-2. Tambi?n
       pueden accederse por su n?mero relativo; en este caso, estos n?meros
       son 1, 3, 6, 1, 2 y 1:

          iso.org.dod.internet.mgmt.mib-2 (1.3.6.1.2.1)

       En algunos programas se usa un punto al iniciar el OID. Esto puede ser
       confuso; no hay ning?n punto inicial en la especificaci?n de los OID...
       sin embargo, algunos programas usan por defecto un prefijo inicial.
       Para indicar la diferencia entre los OID abreviados (o sea, a los que
       se le pondr? el prefijo inicial) y los completos, estos programas nece-
       sitan que los OID completos empiecen por un punto. Para empeorar las
       cosas, se usan varios prefijos distintos...

       De acuerdo, sigamos con el inicio de nuestro OID: ten?amos 1.3.6.1.2.1
       . Ahora, nos interesa la rama ''interfaces'', que tiene el n?mero dos
       (o sea, 1.3.6.1.2.1.2, o 1.3.6.1.2.1.interfaces).

       Lo primero es hacernos con un programa SNMP. Busca alg?n paquete pre-
       compilado para tu plataforma, si no, puedes buscar el c?digo fuente y
       compilarlo tu mismo. En Internet encontrar?s muchos programas, b?scalos
       con un motor de b?squeda o como prefieras.  Mi sugerencia es que
       busques el paquete CMU-SNMP, que esta bastante difundido.

       Asumamos que ya tienes el programa. Empecemos por tomar ciertos datos
       que est?n disponibles en la mayor?a de los sistemas. Recuerda: hay un
       nombre abreviado para la parte del ?rbol que m?s nos interesa.

       Voy a usar la versi?n corta, ya que creo que este documento ya es lo
       bastante largo. Si no te funciona, a??dele el prefijo .1.3.6.1.2.1 y
       prueba de nuevo. O prueba leyendo el manual; s?ltate las partes que no
       entiendas a?n, y busca las secciones que hablan de como arrancar y usar
       el programa.

          snmpget myrouter public system.sysdescr.0

       El dispositivo deber? contestarte con una descripci?n, probablemente
       vac?a, de s? mismo. Si no consigues una respuesta v?lida, prueba con
       otra "clave" u otro dispositivo; no podemos seguir hasta tener un
       resultado.

          snmpget myrouter public interfaces.ifnumber.0

       Con suerte, usando este comando obtendr?s un n?mero como resultado: el
       n?mero de interfaces del dispositivo. Si es as?, seguiremos adelante
       con otro programa, llamado "snmpwalk"

          snmpwalk myrouter public interfaces.iftable.ifentry.ifdescr

       Si obtienes una lista de interfaces, ya casi hemos llegado. Aqu? tienes
       un ejemplo del resultado:

          [user@host /home/alex]$ snmpwalk cisco public 2.2.1.2
          interfaces.ifTable.ifEntry.ifDescr.1 = "BRI0: B-Channel 1"
          interfaces.ifTable.ifEntry.ifDescr.2 = "BRI0: B-Channel 2"
          interfaces.ifTable.ifEntry.ifDescr.3 = "BRI0" Hex: 42 52 49 30
          interfaces.ifTable.ifEntry.ifDescr.4 = "Ethernet0"
          interfaces.ifTable.ifEntry.ifDescr.5 = "Loopback0"

       En este equipo CISCO, quiero monitorizar la interfaz "Ethernet0".
       Viendo que es la cuarta, pruebo con:

          [user@host /home/alex]$ snmpget cisco public 2.2.1.10.4 2.2.1.16.4

          interfaces.ifTable.ifEntry.ifInOctets.4 = 2290729126
          interfaces.ifTable.ifEntry.ifOutOctets.4 = 1256486519

       Entonces, tengo 2 OIDs que monitorizar, y son (en el formato largo,
       ahora):

          1.3.6.1.2.1.2.2.1.10

               y

          1.3.6.1.2.1.2.2.1.16

       , ambas con el n?mero de interfaz de 4

       No te enga?es, esto no lo logre yo al primer intento. Me tom? un tiempo
       entender lo que significaban todos estos n?meros; ayuda cuando se tra-
       ducen en un texto descriptivo... por lo menos, cuando oigas hablar de
       MIBs y OIDs, ahora sabr?s de qu? se trata. No te olvides del n?mero de
       interfaz (0 si el valor no depende de una interfaz), y prueba con snmp-
       walk si no obtienes una respuesta clara con snmpget.

       Si entendiste todo esto, y obtienes resultados del dispositivo con el
       que est?s probando, sigue adelante con el tutorial. Si no, vuelve a
       leer esta secci?n; es importante

       UUnn eejjeemmpplloo rreeaall

       Ok, empecemos con la diversi?n. Primero, crea una base de datos nueva.
       Vamos a guardar en ella 2 contadores, "input" y "ouput". Los datos los
       vamos a guardar en archivos que los promediar?n, tomando grupos de 1,
       6, 24 o 288 muestras. Tambi?n archivaremos los valores m?ximos. Lo
       explicaremos con m?s detalle despu?s. El intervalo de tiempo entre las
       muestras ser? de 300 segundos (5 minutos).

        1 muestra "promediada" sigue siendo 1 muestra cada 5 minutos
        6 muestras promediadas son un promedio de cada 30 minutos
        24 muestras promediadas son un promedio de cada 2 horas
        288 muestras promediadas son un promedio de cada d?a

       Vamos a tratar de ser compatibles con MRTG, que guarda m?s o menos esta
       cantidad de datos:

        600 muestras de 5 minutos:          2 d?as y 2 horas
        600 promedios de 30 minutos:        12.5 d?as
        600 promedios de 2 horas:           50 d?as
        600 promedios de 1 d?a:             732 d?as

       Uniendo todos estos rangos tenemos que en total guardamos datos de unos
       797 d?as. RRDtool guarda los datos de una forma distinta a MRTG; no
       empieza el archivo "semanal" donde acaba el "diario", sino que ambos
       archivos contienen la informaci?n m?s reciente, ?por lo que con RRDtool
       archivamos m?s datos que con MRTG!

       Necesitaremos:

        600 muestras de 5 minutos    (2 d?as y 2 horas)
        700 entradas de 30 minutos   (2 d?as y 2 horas, m?s 12.5 d?as)
        775 entradas de 2 horas      (lo anterior + 50 d?as)
        797 entradas de 1 d?a        (lo anterior + 732 d?as, redondeando)

          rrdtool create myrouter.rrd         \
                   DS:input:COUNTER:600:U:U   \
                   DS:output:COUNTER:600:U:U  \
                   RRA:AVERAGE:0.5:1:600      \
                   RRA:AVERAGE:0.5:6:700      \
                   RRA:AVERAGE:0.5:24:775     \
                   RRA:AVERAGE:0.5:288:797    \
                   RRA:MAX:0.5:1:600          \
                   RRA:MAX:0.5:6:700          \
                   RRA:MAX:0.5:24:775         \
                   RRA:MAX:0.5:288:797

       Lo siguiente es recoger los datos y guardarlos, como en el ejemplo
       siguiente. Esta parcialmente en pseudo-c?digo, por lo que tendr?s que
       buscar exactamente como hacerlo funcionar en tu sistema operativo.

          mientras no sea el fin del universo
          hacer
             tomar el resultado de
                 snmpget router community 2.2.1.10.4
             en la variable $in
             tomar el resultado de
                 snmpget router community 2.2.1.16.4
             en la variable $out
             rrdtool update myrouter.rrd N:$in:$out
             esperar 5 minutos
          hecho

       Luego, tras recoger datos por un d?a, crea una imagen, usando:

          rrdtool graph myrouter-day.gif --start -86400 \
                   DEF:inoctets=myrouter.rrd:input:AVERAGE \
                   DEF:outoctets=myrouter.rrd:output:AVERAGE \
                   AREA:inoctets#00FF00:"In traffic" \
                   LINE1:outoctets#0000FF:"Out traffic"

       Este comando debe producir un gr?fico del tr?fico del d?a. Un d?a son
       24 horas, de 60 minutos, de 60 segundos: 24*60*60=86400, o sea que
       empezamos a "ahora" menos 86400 segundos. Definimos (con los DEFs)
       "inoctets" y "outoctets" como los valores promedio de la base da datos
       myrouter.rrd, dibujando un ?rea para el tr?fico de entrada y una l?nea
       para el tr?fico de salida.

       Mira la imagen y sigue recogiendo datos por unos cuantos d?as. Si lo
       deseas, puedes probar con los ejemplos de la base de datos de pruebas y
       ver si puedes hacer trabajar las diversas opciones y operaciones.

       Sugerencia:

       Haz un gr?fico que muestre el tr?fico en bytes por segundo y en bits
       por segundo. Colorea el tr?fico Ethernet rojo si sobrepasa los cuatro
       megabits por segundo.

       FFuunncciioonneess ddee ccoonnssoolliiddaaccii??nn

       Unos cuantos p?rrafos atr?s habl?bamos sobre la posibilidad de guardar
       el valor m?ximo en vez del promedio. Profundicemos un poco en este
       tema.

       Recordemos lo que habl?bamos sobre la velocidad de un coche.  Supong-
       amos que manejamos a 144 KM/H durante 5 minutos y luego nos detiene la
       polic?a durante unos 25 minutos. Al finalizar el rega?o, tomamos nue-
       stro port?til y creamos una imagen desde nuestra base de datos. Si
       visualizamos la segunda RRA que creamos, tendremos el promedio de 6
       muestreos. Las velocidades registradas serian 144+0+0+0+0+0=144, lo que
       en promedio nos da una velocidad de 24 KM/H., con lo que nos igual nos
       pondr?an una multa, s?lo que no por exceso de velocidad.

       Obviamente, en este caso, no deber?amos tomar en cuenta los promedios.
       Estos son ?tiles en varios casos. Por ejemplo, si queremos ver cuantos
       KM hemos viajado, este ser?a el gr?fico m?s indicado. Pero por otro
       lado, para ver la velocidad ha la que hemos viajado, los valores
       m?ximos son m?s adecuados.

       Es lo mismo con los datos que recogemos. Si quieres saber la cantidad
       total, mira los promedios. Si quieres ver la velocidad, mira los
       m?ximos. Con el tiempo, ambas cantidades se separan cada vez m?s.  En
       la ?ltima base de datos que creamos, hab?a dos archivos que guardaban
       los datos de cada d?a. El archivo que guarda los promedios mostrar?
       valores bajos, mientras que el de m?ximos mostrar? valores m?s altos.
       Para mi coche, mostrar?a valores promedio de 96/24=4 KM/H (viajo unos
       96 kil?metros por d?a), y m?ximos de 1220 KM/H (la velocidad m?xima que
       alcanzo cada d?a)

       Como ves, una gran diferencia. No mires el segundo gr?fico para estimar
       la distancia que recorro, ni al primero para estimar la velocidad a la
       que voy. Esto s?lo funciona con muestras muy cercanas, pero no si sacas
       promedios.

       Algunas veces, hago un viaje largo. Si hago un recorrido por Europa,
       conduciendo por unas 12 horas, el primer gr?fico subir? a unos 60 KM/H.
       El segundo mostrar? unos 180 KM/H. Esto significa que recorr? unos 60
       KM/H por 24 horas = 1440 KM. Muestra adem?s que fui a una velocidad
       promedio mayor a la normal y a un m?ximo de 180 KM/H, ?no que fui 8
       horas a una velocidad fija de 180 KM/H! Este es un ejemplo real: tengo
       que seguir la corriente en las autopistas de Alemania, detenerme por
       gasolina y caf? de vez en cuando, manejar m?s lentamente por Austria y
       Holanda, e ir con cuidado en las monta?as y las villas. Si vi?ramos los
       gr?ficos de los promedios de cada 5 minutos, la imagen ser?a completa-
       mente distinta; ver?amos los mismos valores de promedio y de m?xima.
       (suponiendo que las mediciones fueran cada 300 segundos). Se podr?a ver
       cuando par?, cuando iba en primera, cuando iba por las autopistas, etc.
       La granularidad de los datos es m?s alta, por lo que se tiene m?s
       informaci?n. Sin embargo, esto nos lleva unas 12 muestras por hora, o
       288 al d?a, lo cual es mucho para guardar por un periodo de tiempo
       largo. Por lo tanto, sacamos el promedio, guardando eventualmente un
       solo valor por d?a.  Con este ?nico valor, no podemos ver mucho.

       Es importante comprender lo que expuesto en estos ?ltimos p?rrafos.
       Unos ejes y unas l?neas no tienen ning?n valor por si mismos; hay que
       saber que representan e interpretar correctamente los valores
       obtenidos. Sean cuales sean los datos, esto siempre ser? cierto.

       El mayor error que puedes cometer es usar los datos recogidos para algo
       para lo cual no sirven. En ese caso, seria hasta mejor no tener gr?fico
       alguno.

       RReeppaasseemmooss lloo qquuee ssaabbeemmooss

       Ahora ya sabes como crear una base de datos. Puedes guardar valores en
       ella, extraerlos creando un gr?fico, hacer operaciones matem?ticas con
       ellos desde la base de datos y visualizar los resultados de estas en
       vez de los datos originales. Vimos la diferencia entre los promedios y
       los m?ximos y cuando debemos usar cada uno (o al menos una idea de
       ello)

       RRDtool puede hacer m?s de lo que hemos visto hasta ahora. Pero antes
       de continuar, te recomiendo que releas el texto desde el principio y
       pruebes a hacerle algunas modificaciones a los ejemplos.  Aseg?rate de
       entenderlo todo. El esfuerzo valdr? la pena, y te ayudar?, no s?lo con
       el resto del documento, sino en tu trabajo diario de monitorizaci?n,
       mucho despu?s de terminar con esta introducci?n.

       TTiippooss ddee ffuueenntteess ddee ddaattooss

       De acuerdo, quieres continuar. Bienvenido de vuelta otra vez y
       prep?rate; voy a ir m?s r?pido con los ejemplos y explicaciones.

       Ya vimos que, para ver el cambio de un contador a lo largo del tiempo,
       tenemos que tomar dos n?meros y dividir la diferencia entre el tiempo
       transcurrido entre las mediciones. Para los ejemplos que hemos visto es
       lo l?gico, pero hay otras posibilidades. Por ejemplo, mi enrutador me
       puede dar la temperatura actual en tres puntos distintos, la entrada de
       aire, el llamado "punto caliente" y la salida de ventilaci?n. Estos
       valores no son contadores; si tomo los valores de dos muestreos y lo
       divido entre 300 segundos, obtendr? el cambio de temperatura por
       segundo. ?Esperemos que sea cero, o tendr?amos un incendio en el cuarto
       de ordenadores! :)

       Entonces, ?que hacemos? Podemos decirle a RRDtool que guarde los val-
       ores tal como los medimos (esto no es exactamente as?, pero se aproxima
       bastante a la verdad). As?, los gr?ficos se ver?n mucho mejor. Puedo
       ver cuando el enrutador est? trabajando m?s (en serio, funciona; como
       usa m?s electricidad, genera m?s calor y sube la temperatura), puedo
       saber cuando me he dejado las puertas abiertas (el cuarto de orde-
       nadores tiene aire acondicionado; con las puertas abiertas el aire
       caliente del resto del edificion entra y sube la temperatura en la
       entrada de aire del enrutador), etc. Antes usamos un tipo de datos de
       "contador", ahora usaremos un tipo de datos diferente, con un nombre
       diferente, GAUGE.  Tenemos otros tipos:

        - COUNTER este ya lo conocemos
        - GAUGE   este acabamos de verlo
        - DERIVE
        - ABSOLUTE

       Los otros dos tipos son DERIVE y ABSOLUTE. ABSOLUTE puede usarse igual
       que COUNTER, con una diferencia; RRDtool asume que el contador se
       reinicia cada vez que se lee. O en otras palabras; el delta entre los
       valores no hay que calcularlo, mientras que con COUNTER RRDtool tiene
       que sacar ?l la cuenta. Por ejemplo, nuestro primer ejemplo, (12345,
       12357, 12363, 12363), ser?a (unknown, 12, 6, 0) en ABSOLUTE.  El otro
       tipo, DERIVE, es como COUNTER, pero al contrario de COUNTER, este valor
       tambi?n puede decrecer, por lo que puede tenerse un delta negativo.

       Vamos a probarlos todos:

          rrdtool create all.rrd --start 978300900 \
                   DS:a:COUNTER:600:U:U \
                   DS:b:GAUGE:600:U:U \
                   DS:c:DERIVE:600:U:U \
                   DS:d:ABSOLUTE:600:U:U \
                   RRA:AVERAGE:0.5:1:10
          rrdtool update all.rrd \
                   978301200:300:1:600:300    \
                   978301500:600:3:1200:600   \
                   978301800:900:5:1800:900   \
                   978302100:1200:3:2400:1200 \
                   978302400:1500:1:2400:1500 \
                   978302700:1800:2:1800:1800 \
                   978303000:2100:4:0:2100    \
                   978303300:2400:6:600:2400  \
                   978303600:2700:4:600:2700  \
                   978303900:3000:2:1200:3000
          rrdtool graph all1.gif -s 978300600 -e 978304200 -h 400 \
                   DEF:linea=all.rrd:a:AVERAGE LINE3:linea#FF0000:"Line A" \
                   DEF:lineb=all.rrd:b:AVERAGE LINE3:lineb#00FF00:"Line B" \
                   DEF:linec=all.rrd:c:AVERAGE LINE3:linec#0000FF:"Line C" \
                   DEF:lined=all.rrd:d:AVERAGE LINE3:lined#000000:"Line D"

       RRRRDDttooooll bbaajjoo eell mmiiccrroossccooppiioo


       ?   La l?nea A es un contador, por lo que debe incrementarse continua-
           mente y RRDtool tiene que calcular las diferencias. Adem?s RRDtool
           tiene que dividir la diferencia entre el tiempo transcurrido. Esto
           deber?a terminar con una l?nea recta en 1 (los deltas son 300, y
           los intervalos son de 300)

       ?   La l?nea B es de tipo GAUGE. Estos son los valores "reales", as?
           que el gr?fico debe mostrar lo mismo que los valores que introduci-
           mos: una especie de onda

       ?   La l?nea C es de tipo DERIVE. Es un contador, y puede decrecer. Va
           entre 2400 y 0, con 1800 en el medio.

       ?   La l?nea D es de tipo ABSOLUTE. Esto es, es un contador pero no hay
           que calcular las diferencias. Los n?meros son iguales a la l?nea A,
           y espero que puedas ver la diferencia en los gr?ficos.

       Esto equivale a los valores siguientes, empezando a las 23:10 y termi-
       nando a las 00:10 (las U significan desconocido).

        - L?nea  A:  u  u  1  1  1  1  1  1  1  1  1  u
        - L?nea  B:  u  1  3  5  3  1  2  4  6  4  2  u
        - L?nea  C:  u  u  2  2  2  0 -2 -6  2  0  2  u
        - L?nea  D:  u  1  2  3  4  5  6  7  8  9 10  u

       Si tu archivo GIF muestra todo esto, has entrado los datos correcta-
       mente, tu programa RRDtool est? funcionando bien, el visor de gr?ficos
       no te enga?a y hemos entrado en el 2000 sin problemas :) Puedes probar
       el mismo ejemplo cuatro veces, una por cada l?nea.

       Revisemos los datos otra vez:

       ?   L?nea A: 300, 600, 900 , etc.  La diferencia del contador es siem-
           pre 300, igual que el intervalo de tiempo transcurrido entre medi-
           ciones. Por lo tanto, el promedio siempre es 1. Pero, ?por qu? el
           primer punto tiene un valor de "desconocido"? ?Acaso no era cono-
           cido el valor que pusimos en la base de datos? ?Si! Pero no
           ten?amos un valor inicial para calcular la diferencia. Ser?a un
           error asumir que el contador empezaba en 0, as? que no conocemos el
           valor de la diferencia

       ?   L?nea B: No hay nada que calcular, los valores son los mismos que
           se introdujeron en la base de datos.

       ?   L?nea C: De nuevo, no conocemos el valor inicial antes de la
           primera medici?n, as? que se aplica el mismo razonamiento que para
           la l?nea A. En este caso las diferencias no son constantes, as? que
           la l?nea no es recta. Si hubi?semos puesto los mismos valores que
           en la l?nea A, el gr?fico ser?a el mismo. Al contrario que COUNTER,
           el valor puede decrecer, y espero mostrarte m?s adelante el por que
           de la diferencia entre ambos tipos.

       ?   L?nea D: En este caso, el dispositivo nos da las diferencias por s?
           mismo. Por lo tanto, conocemos la diferencia inicial, y podemos
           graficarla. Tenemos los mismos valores que en la l?nea A, pero su
           significado es distinto, por lo que el gr?fico tambi?n lo es. En
           este caso, las diferencias se incrementan en 300 cada vez, mientras
           que el intervalo de tiempo permanece constante en 300 segundos, por
           lo que la divisi?n nos da resultados cada vez mayores.

       RReeiinniicciiaalliizzaaccii??nn ddee llooss ccoonnttaaddoorreess

       Todav?a nos quedan algunas cosas por ver. Nos quedan algunas opciones
       importantes por cubrir, y aun no hemos hablado de la reinicializaci?n
       de contadores. Empecemos por ah?: Estamos en nuestro coche, vemos el
       contador y muestra 999987. Andamos unos 20 KM, as? que el contador debe
       subir a 1000007. Desafortunadamente, el contador s?lo tiene 6 d?gitos,
       as? que en realidad nos muestra 000007. Si estuvi?ramos guardando los
       valores en un tipo DERIVE, esto significar?a que el contador retrocedi?
       unos 999980 KM. Por supuesto esto no es cierto, por lo que necesitamos
       alguna protecci?n contra estos casos. Esta protecci?n s?lo la tenemos
       para el tipo COUNTER, el cual de todas formas era el que ten?amos que
       haber usado para este tipo de contador. ?C?mo funciona? Los valores
       tipo COUNTER no deben decrecer nunca, ?por lo que RRDtool asume en ese
       caso que el contador se ha reinicializado! Si la diferencia es nega-
       tiva, esto se compensa sumando el valor m?ximo del contador + 1. Para
       nuestro coche, tendr?amos:

        Delta = 7 - 999987 = -999980    (en vez de 1000007-999987=20)

        Delta real= -999980 + 999999 + 1 = 20

       Al momento de escribir este documento, RRDtool maneja contadores de 32
       o 64 bits de tama?o. Estos contadores pueden manejar los siguientes
       valores:

        - 32 bits: 0 ..           4294967295
        - 64 bits: 0 .. 18446744073709551615

       Si estos valores te parecen raros, podemos verlos en formato hexadeci-
       mal:

        - 32 bits: 0 ..         FFFFFFFF
        - 64 bits: 0 .. FFFFFFFFFFFFFFFF

       RRDtool maneja ambos contadores de la misma manera. Si ocurre un des-
       bordamiento y la diferencia es negativa, RRDtool le suma primero el
       m?ximo del contador "menor" (32 bits) + 1 a la diferencia. Si a?n as?
       la diferencia es negativa, entonces el contador reinicializado era
       mayor (64 bits), por lo que se le suma el valor m?ximo del contador
       "largo" + 1 y se le resta el m?ximo del contador "peque?o" que sumamos
       err?neamente. Hay un problema con esto: supongamos que un contador
       largo se ha reinicializado al sum?rsele una diferencia muy grande;
       entonces es posible que al a?adir el valor m?ximo del contador peque?o
       la diferencia nos d? positivo. En este caso poco probable, los valores
       resultantes no serian correctos. Para que ocurra esto, el incremento
       tiene que ser casi tan grande como el valor m?ximo del contador, por lo
       que de ocurrir es muy probable que halla varios problemas m?s en la
       configuraci?n y no merezca la pena preocuparse s?lo por este. A?n as?,
       he incluido un ejemplo de este caso para que lo puedas juzgar por ti
       mismo.

       A continuaci?n, unos ejemplos de reinicializaci?n de los contadores.
       Prueba de hacer los c?lculos por ti mismo, o acepta mis resultados si
       tu calculadora no puede con los n?meros :)

       N?meros de correcci?n:

        - 32 bits: (4294967295+1) =                                 4294967296
        - 64 bits: (18446744073709551615+1)-correction1 = 18446744069414584320

        Antes:          4294967200
        Incremento:            100
        Deber?a ser:    4294967300
        Pero es:                 4
        Diferencia:    -4294967196
        Correcci?n #1: -4294967196 + 4294967296 = 100

        Antes:          18446744073709551000
        Incremento:                      800
        Deber?a ser:    18446744073709551800
        Pero es:                         184
        Diferencia:    -18446744073709550816
        Correcci?n #1: -18446744073709550816 +4294967296 = -18446744069414583520
        Correcci?n #2: -18446744069414583520 +18446744069414584320 = 800

        Antes:          18446744073709551615 ( valor m?ximo )
        Incremento:     18446744069414584320 ( incremento absurdo,
        Deber?a ser:    36893488143124135935   m?nimo para que
        Pero es:        18446744069414584319   funcione el ejemplo)
        Diferencia:              -4294967296
        Correcci?n #1:  -4294967296 + 4294967296 = 0 (positivo,
                                                      por tanto no se hace
                                                      la segunda correcci?n)

        Antes:          18446744073709551615 ( valor m?ximo )
        Incremento:     18446744069414584319
        Deber?a ser:    36893488143124135934
        Pero es:        18446744069414584318
        Diferencia:              -4294967297
        Correcci?n #1:  -4294967297 +4294967296 = -1
        Correcci?n #2:  -1 +18446744069414584320 = 18446744069414584319

       Como puede verse en los ?ltimos ejemplos, necesitas unos valores bas-
       tante extra?os para hacer que RRDtool falle (asumiendo que no tenga
       ning?n error el programa, por supuesto), as? que esto no deber?a ocur-
       rir. Sin embargo, SNMP o cualquier otro m?todo que uses de recogida de
       datos puede tambi?n reportar alg?n valor err?neo ocasionalmente. No
       podemos prevenir todos los errores, pero podemos tomar algunas medidas.
       El comando "create" de RRDtool tiene dos par?metros especialmente para
       esto, que definen los valores m?nimo y m?ximo permitidos. Hasta ahora
       hemos usado "U", "desconocido". Si le pasas valores para uno o ambos
       par?metros y RRDtool recibe un valor fuera de esos l?mites, los igno-
       rar?. Para un term?metro en grados Celsius, el m?nimo absoluto es -273.
       Para mi enrutador, puedo asumir que ese m?nimo es mucho mayor, digamos
       que 10.  La temperatura m?xima la pondr?a en unos 80 grados; m?s alto y
       el aparato no funcionar?a. Para mi coche, nunca esperar?a obtener val-
       ores negativos, y tampoco esperar?a valores mayores a 230.  Cualquier
       otra cosa ser?a un error. Pero recuerda, lo contrario no es cierto: si
       los valores pasan este examen no quiere decir que sean los correctos.
       Siempre examina bien el gr?fico si los valores parecen extra?os.

       RReemmuueessttrreeoo ddee llooss ddaattooss

       Hay una funcionalidad importante de RRDtool que no hemos explicado
       todav?a: es virtualmente imposible recoger los datos y pasarselos a
       RRDtool a intervalos exactos de tiempo. Por tanto, RRDtool interpola
       los datos a los intervalos exactos. Si no sabes que significa esto o
       como se hace, he aqu? la ayuda que necesitas:

       Supongamos un contador se incremente exactamente en 1 cada segundo.
       Queremos medirlo cada 300 segundos, por lo que deber?amos tener valores
       separados exactamente en 300. Sin embargo, por varias circunstancias
       llegamos unos segundos tarde y el intervalo es 303. La diferencia ser?
       por tanto 303. Obviamente, RRDtool no debe colocar 303 en la base de
       datos y dar as? la impresi?n de que el contador se increment? 303 en
       300 segundos. Aqu? es donde RRDtool interpola: alter? el valor 303 al
       valor que tendr?a 3 segundos antes y guarda 300 en 300 segundos. Dig-
       amos que la pr?xima vez llegamos justo a tiempo; por tanto, el inter-
       valo actual es 297 segundos, por lo que el contador deber?a ser 297. De
       nuevo, RRDtool altera el valor y guarda 300, como debe ser.

                en RRD                     en realidad
        tiempo+000:   0 delta="U"    tiempo+000:   0 delta="U"
        tiempo+300: 300 delta=300    tiempo+300: 300 delta=300
        tiempo+600: 600 delta=300    tiempo+603: 603 delta=303
        tiempo+900: 900 delta=300    tiempo+900: 900 delta=297

       Creemos dos bases de datos id?nticas. He escogido el rango de tiempo
       entre 920805000 y 920805900.

          rrdtool create seconds1.rrd   \
             --start 920804700          \
             DS:seconds:COUNTER:600:U:U \
             RRA:AVERAGE:0.5:1:24

          para Unix: cp seconds1.rrd seconds2.rrd
          para DOS: copy seconds1.rrd seconds2.rrd
          para VMS:  y yo que s? :)

          rrdtool update seconds1.rrd \
             920805000:000 920805300:300 920805600:600 920805900:900
          rrdtool update seconds2.rrd \
             920805000:000 920805300:300 920805603:603 920805900:900

          rrdtool graph seconds1.gif                       \
             --start 920804700 --end 920806200             \
             --height 200                                  \
             --upper-limit 1.05 --lower-limit 0.95 --rigid \
             DEF:seconds=seconds1.rrd:seconds:AVERAGE      \
             CDEF:unknown=seconds,UN                       \
             LINE2:seconds#0000FF                          \
             AREA:unknown#FF0000
          rrdtool graph seconds2.gif                       \
             --start 920804700 --end 920806200             \
             --height 200                                  \
             --upper-limit 1.05 --lower-limit 0.95 --rigid \
             DEF:seconds=seconds2.rrd:seconds:AVERAGE      \
             CDEF:unknown=seconds,UN                       \
             LINE2:seconds#0000FF                          \
             AREA:unknown#FF0000

       Los dos gr?ficos debe ser iguales.

RREESSUUMMEENN
       Es hora de concluir este documento. Ahora debes conocer lo b?sico como
       para trabajar con RRDtool y leer la documentaci?n. A?n hay mucho m?s
       por descubrir acerca de RRDtool, y le encontrar?s; m?s y m?s usos para
       la herramienta. Con los ejemplos y la herramienta puedes crear f?cil-
       mente muchos gr?ficos; tambi?n puedes usar las interfaces disponibles.

LLIISSTTAA DDEE CCOORRRREEOO
       Recuerda subscribirte a la lista de correo. Aunque no contestes los
       correos que aparecen en ella, te servir? de ayuda a ti y a los dem?s.
       Mucho de lo que se sobre MRTG (y por tanto sobre RRDtool), lo aprend?
       tan s?lo con leer la lista, sin escribir. No hay por que preguntar las
       preguntas b?sicas, que ya tienen su respuesta en la FAQ (?l?ela!). Con
       miles de usuarios a lo largo del mundo, siempre hay preguntas que tu
       puedes responder con lo aprendido en este y otros documentos.

VVEERR TTAAMMBBII??NN
       Las p?ginas del manual de RRDtool

AAUUTTOORR
       Espero que hayas disfrutado con los ejemplos y las descripciones.  Si
       es as?, ayuda a otros refiri?ndolos a este documento cuando te hagan
       preguntas b?sicas. No s?lo obtendr?n la respuesta, sino que aprender?n
       muchas otras cosas.

       Alex van den Bogaerdt <alex@ergens.op.het.net>



1.0.50                            2004-01-17                 RRDTUTORIAL.ES(1)
