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



NNAAMMEE
       rrdtutorial - Tutorial sobre RRDtool por Alex van den Bogaerdt (Tra-
       ducido al castellano por Jesus Couto Fandino)

DDEESSCCRRIIPPTTIIOONN
       RRDtool es un programa escrito por Tobias Oetiker con la colaboracion
       de muchas personas en diversas partes del mundo. Alex van den Bogaerdt
       escribio este documento para ayudarte a entender que es RRDtool y que
       es lo que puede hacer por ti.

       La documentacion que viene con RRDtool puede ser demasiado tecnica para
       algunos. Este tutorial existe para ayudarte a entender las funciones
       basicas de RRdtool. Debe servirte de preparacion para leer la docu-
       mentacion, y ademas explica algunas ideas generales sobre estadistica,
       con un enfoque particular hacia las redes.

TTUUTTOORRIIAALL
       IImmppoorrttaannttee

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

       ??QQuuee eess RRRRDDttooooll??

       RRDtool significa "herramienta de bases de datos en round robin".
       "Round robin" es una tecnica que implica un numero fijo de datos, y un
       apuntador al elemento mas 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 circulo a uno de los puntos; este es el apuntador.  Cuando
       se lee o escribe el dato actualmente apuntado, la flecha se mueve al
       proximo elemento. Como estamos en un circulo, no hay ni principio ni
       fin; siempre puedes seguir, eternamente. Al cabo de un tiempo ya se
       habran usado todas las posiciones disponibles y el proceso empieza a
       reutilizar las antiguas. De esta forma, la base de datos no crece en
       tamano y, por lo tanto, no requiere ningun mantenimiento.  RRDtool tra-
       baja con estas bases de datos en "round-robin", guardando y recuperando
       datos de ellas.

       ??QQuuee ddaattooss ppuueeddeenn gguuaarrddaarrssee eenn uunnaa RRRRDD??

       Lo que se te ocurra. Debes poder medir algun 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
       numericos, pero no necesariamente enteros, como en MRTG.

       Muchos ejemplos mencionan SNMP, que es el acronimo de "Simple Network
       Management Protocol" (Protocolo Simple de Administracion de Redes). Lo
       de "simple" se refiere al protocolo - no se supone que sea facil admin-
       istrar o monitorizar una red. Cuando hayas terminado con este docu-
       mento, deberas 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.

       ??QQuuee ppuueeddoo hhaacceerr ccoonn eessttaa hheerrrraammiieennttaa??

       RRDtool se deriva de MRTG (Multi Router Traffic Grapher, Graficador De
       Trafico de Multiples Enrutadores).  MRTG empezo como un pequeno script
       para poder graficar el uso de una conexion a la Internet. Luego evolu-
       ciono, permitiendo graficar otras fuentes de datos, como temperatura,
       velocidad, voltajes, cantidad de paginas impresas, etc... Lo mas proba-
       ble es que empieces a usar RRDtool para guardar y procesar datos con-
       seguidos a traves de SNMP, y que los datos sean el numero 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 graficos en formato GIF o PNG, para mostrarlos en un navegador
       web. Esas imagenes 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 trafico que ocurrieron.  Tambien lo puedes usar para mostrar el
       nivel de las mareas, la radiacion solar, el consumo de electricidad, el
       numero de visitantes en una exposicion 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 algun sensor con el cual medir los datos y seas capaz
       de pasarle los numeros a RRDtool.

       ??YY ssii aauunn tteennggoo pprroobblleemmaass ddeessppuueess ddee lleeeerr eessttee ddooccuummeennttoo??

       Lo primero, ?leelo otra vez!. Puede que te hayas perdido de algo.  Si
       no puedes compilar el codigo fuente y usas un sistema operativo bas-
       tante comun, casi seguro que no es la culpa de RRDtool.  Probablemente
       consigas versiones pre-compiladas por la Internet. Si provienen de una
       fuente confiable, usalas. Si, por otro lado, el programa funciona, pero
       no te da los resultados que tu esperabas, puede ser un problema con la
       configuracion; revisala y comparala con los ejemplos.

       Hay una lista de correo electronico y una archivo de la misma. Lee la
       lista durante unas cuantas semanas, y busca en el archivo. Es descortes
       hacer una pregunta sin haber revisado el archivo; ?puede que tu prob-
       lema ya haya sido resuelto antes! Normalmente ocurre asi en todas las
       listas de correo, no solo esta. Examina la documentacion que vino con
       RRDtool para ver donde esta 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
       titulo "subscribe". Si eventualmente deseas salirte de la lista, envia
       otro correo a la misma direccion, con titulo "unsubscribe".

       ??CCoommoo mmee vvaass aa aayyuuddaarr??

       Dandote descripciones y ejemplos detallados. Asumimos que el seguir las
       instrucciones en el orden en que se presentan aqui te dara 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 obtendras algo de experiencia practica y, lo que es mas
       importante, un poco de informacion sobre como funciona el programa.

       Necesitaras saber algo sobre numeros hexadecimales. Si no, empieza por
       leer "bin_dec_hex" antes de continuar.

       TTuu pprriimmeerraa bbaassee ddee ddaattooss eenn rroouunndd--rroobbiinn

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

       Empezaremos con algo facil, comparando un coche con un enrutador, o por
       decirlo de otra forma, comparando kilometros con bits y bytes. A
       nosotros nos da lo mismo; son unos numeros 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 maximo; si ese valor se alcanza y se cuenta un byte mas,
       el contador vuelve a empezar desde cero. Esto es exactamente lo mismo
       que pasa con muchos contadores, como el cuentakilometros del coche. En
       muchas de las disertaciones sobre redes se habla de bits por segundo,
       asi 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 mayoria 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 ultima vez que
       le preguntamos, sabemos cuantos bytes se han transferido "***en prome-
       dio***" por segundo. Esto no es muy dificil de calcular; primero en
       palabras, luego en operaciones:

       1.  Toma el valor actual del contador y restale 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 sera de ayuda traducir esto a un ejemplo automotor.  No
       prueben estas velocidades en la practica, y si lo hacen, no me echen la
       culpa por los resultados.

       Usaremos las siguientes abreviaturas:

        M:    metros
        KM:   kilometros (= 1000 metros).
        H:    horas
        S:    segundos
        KM/H: kilometros 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 cientifico convertiria 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 kilometros, que son 12000 metros. Tardamos 5 minutos, o sea
       300 segundos. Nuestra velocidad es 12000M / 300S igual a 40 M/S.

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

       Recuerda que estos numeros son tan solo promedios. No hay forma de
       deducir, viendo solo los numeros, si fuiste a una velocidad constante.
       Hay un ejemplo mas adelante en el tutorial que explica esto.

       Espero que entiendas que no hay diferencia entre calcular la velocidad
       en M/S o bps; solo 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 metodo a usar para arrancar el programa puede
       variar de un sistema de operacion a otro, pero asumamos que lo puedes
       resolver tu mismo en caso que se diferente en el sistema que usas.
       Asegurate de no sobreescribir ningun archivo en tu sistema al ejecu-
       tarlo y escribe todo como una sola linea (tuve que partirlo para que
       fuera legible), saltandote 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 ...")

       ??QQuuee hheemmooss ccrreeaaddoo??

       Hemos creado una base de datos en round robin llamada test (test.rrd),
       que empieza desde el mediodia del dia en que empece 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 mas adelante.

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

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

       Ahora tenemos que llenar nuestra base de datos con valores. Vamos a
       suponer que leimos 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 asi:

        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

        etcetera.

       Como ves, pueden introducirse mas de un valor en la base de datos por
       ejecucion del comando. Yo los agrupo de tres en tres para hacerlo legi-
       ble, pero en realidad el maximo depende del sistema de operacion.

       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 operacion muestre
       ''NaN'' de otra forma; representa "Not a Number", o sea "No es un
       numero". Si aparece ''U'' o ''UNKN'' o algo parecido, es lo mismo. Si
       hay alguna otra diferencia, probablemente te equivocaste al introducir
       algun P valor (asumiendo que mi tutorial esta bien, por supuesto :-).
       En ese caso, borra la base de datos y prueba de nuevo.

       Lo que representa exactamente esta salida lo vamos mas adelante en el
       tutorial.

       HHoorraa ddee hhaacceerr aallgguunnooss ggrraaffiiccooss

       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 grafico de los datos desde las 12:00
       hasta las 13:00. Contiene una definicion de la variable myspeed y
       define el color como rojo. Notaras que el grafico 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 solo ocurre en caso de que se pierdan algun muestreo, lo
       que esperamos que no debe ocurrir muy a menudo.

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

       La definicion 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 maxima 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 mostraran usando la URL
       ''file://el/camino/de/directorios/hasta/speed.gif''

       GGrraaffiiccooss ccoonn uunn ppooccoo ddee mmaatteemmaattiiccaa

       Cuando veas la imagen, notaras 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,
       asi que el programa se los salta. El eje vertical muestra el rango de
       los valores que entramos. Introdujimos los kilometros 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, kilometros o milimetros!.
       RRDtool no sabe nada de unidades, el solo trabaja con numeros, no con
       metros.

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

       Vamos a corregirlo. Podriamos recrear la base de datos con los valores
       correctos, pero hay una forma mejor: ?haciendo los calculos 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, notaras que la ''m'' ha desaparecido, y ahora
       tienes los resultados correctos. Ademas hemos anadido una etiqueta a la
       imagen. Apartando esto, el archivo GIF es el mismo.

       Las operaciones estan en la seccion del CDEF y estan escritas en
       Notacion Polaca Inversa (Reverse Polish Notation o ''RPN''). En pal-
       abras, dice: "toma la fuente de datos myspeed y el numero 1000, y mul-
       tiplicalos". No te molestes en meterte con RPN todavia, la veremos con
       mas detalle mas adelante. Ademas, 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,
       ?tambien deberia ser posible el mostrar la velocidad en kilometros 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
       kilometros por hora. Todo junto hace valor * (3600/1000) == valor *
       3.6.

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

       Ahora vamos a crear este gif, agreandole un poco mas 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 ademas tenemos una linea
       extra mostrando la velocidad maxima permitida (en el camino por donde
       conduzco). Tambien le cambie los colores de la velocidad, y ahora paso
       de ser una linea a un area.

       Los calculos son mas complejos ahora. Para calcular la velocidad
       "aceptable":

          Verifica si la velocidad en kmh es mayor que 100     ( kmh,100 ) GT
          Si es asi, 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 asi, retorna la velocidad, si no, retorna 0    ((( kmh,100) GT ), kmh, 0) IF

       MMaaggiiaa ggrraaffiiccaa

       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 pagina 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>

       Guardalo como ''speed.html'' o algo parecido, y examinalo 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 asegurate que se carguen de nuevo en tu navegador (Nota:
       presionar el boton de "refrescar" puede no ser suficiente; en particu-
       lar, Netscape tiene un problema al respecto, por lo que necesitaras
       darle al boton mientras presionas la tecla de mayusculas.

       AAccttuuaalliizzaacciioonneess ddee vveerrddaadd

       Ya hemos usado el comando ''update''; vimos que recibia uno o mas
       parametros en el formato: ''<fecha>:<valor>''. Para facilitarte las
       cosas, puedes obtener la fecha actual colocando ''N'' en la fecha.
       Tambien podrias usar la funcion ''time'' de Perl para obtenerla. El
       ejemplo mas 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 operacion. La actualizacion, en
       pseudo-codigo, seria:

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

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

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

       UUnnaass ppaallaabbrraass ssoobbrree SSNNMMPP

       Me imagino que muy pocas personas seran capaces de obtener en su orde-
       nador datos reales de su coche cada 5 minutos; los demas nos tendremos
       que conformar con algun otro contador. Puedes, por ejemplo, medir la
       cantidad de paginas que ha hecho una impresora, cuanto cafe 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. Mas adelante, veremos
       tambien como monitorizar otro tipo de valores, como la temperatura. La
       mayoria usaremos alguna vez un contador que lleve la cuenta de cuantos
       octetos (bytes) a transferido un dispositivo de red, asi que vamos a
       ver como hacer esto. Empezaremos describiendo como recoger los datos.
       Hay quien dira 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 porque algo no funciona, nece-
       sitas saber como 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 mas adelante se llama ''snmpget'', y
       funciona asi:

          snmpget dispositivo clave OID

       En "dispositivo" colocas el nombre o direccion 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
       aceptaran "public" como cadena por defecto, pero por razones de pri-
       vacidad y seguridad esta clave puede estar deshabilitada. Consulta la
       documentacion correspondiente al dispositivo o programa.

       Luego esta el tercer parametro, 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 Informacion Administrativa). Es un
       arbol invertido que describe los datos, empezando en un nodo raiz 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 arbol. En este ejemplo, las ramas que
       vamos a tomar se llaman iso, org, dod, internet, mgmt y mib-2. Tambien
       pueden accederse por su numero relativo; en este caso, estos numeros
       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 ningun punto inicial en la especificacion 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 pondra 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: teniamos 1.3.6.1.2.1
       . Ahora, nos interesa la rama ''interfaces'', que tiene el numero 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 algun paquete pre-
       compilado para tu plataforma, si no, puedes buscar el codigo fuente y
       compilarlo tu mismo. En Internet encontraras muchos programas, buscalos
       con un motor de busqueda 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 estan disponibles en la mayoria de los sistemas. Recuerda: hay un
       nombre abreviado para la parte del arbol que mas nos interesa.

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

          snmpget myrouter public system.sysdescr.0

       El dispositivo debera contestarte con una descripcion, probablemente
       vacia, de si mismo. Si no consigues una respuesta valida, 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 obtendras un numero como resultado: el
       numero de interfaces del dispositivo. Si es asi, seguiremos adelante
       con otro programa, llamado "snmpwalk"

          snmpwalk myrouter public interfaces.iftable.ifentry.ifdescr

       Si obtienes una lista de interfaces, ya casi hemos llegado. Aqui 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 numero de interfaz de 4

       No te enganes, esto no lo logre yo al primer intento. Me tomo un tiempo
       entender lo que significaban todos estos numeros; ayuda cuando se tra-
       ducen en un texto descriptivo... por lo menos, cuando oigas hablar de
       MIBs y OIDs, ahora sabras de que se trata. No te olvides del numero 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 estas probando, sigue adelante con el tutorial. Si no, vuelve a
       leer esta seccion; es importante

       UUnn eejjeemmpplloo rreeaall

       Ok, empecemos con la diversion. 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 promediaran, tomando grupos de 1,
       6, 24 o 288 muestras. Tambien archivaremos los valores maximos. Lo
       explicaremos con mas detalle despues. El intervalo de tiempo entre las
       muestras sera 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 dia

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

        600 muestras de 5 minutos:          2 dias y 2 horas
        600 promedios de 30 minutos:        12.5 dias
        600 promedios de 2 horas:           50 dias
        600 promedios de 1 dia:             732 dias

       Uniendo todos estos rangos tenemos que en total guardamos datos de unos
       797 dias. 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 informacion mas reciente, ?por lo que con RRDtool
       archivamos mas datos que con MRTG!

       Necesitaremos:

        600 muestras de 5 minutos    (2 dias y 2 horas)
        700 entradas de 30 minutos   (2 dias y 2 horas, mas 12.5 dias)
        775 entradas de 2 horas      (lo anterior + 50 dias)
        797 entradas de 1 dia        (lo anterior + 732 dias, 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-codigo, por lo que tendras 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 dia, 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 grafico del trafico del dia. Un dia 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 area para el trafico de entrada y una linea
       para el trafico de salida.

       Mira la imagen y sigue recogiendo datos por unos cuantos dias. 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 grafico que muestre el trafico en bytes por segundo y en bits
       por segundo. Colorea el trafico Ethernet rojo si sobrepasa los cuatro
       megabits por segundo.

       FFuunncciioonneess ddee ccoonnssoolliiddaacciioonn

       Unos cuantos parrafos atras hablabamos sobre la posibilidad de guardar
       el valor maximo en vez del promedio. Profundicemos un poco en este
       tema.

       Recordemos lo que hablabamos sobre la velocidad de un coche.  Supong-
       amos que manejamos a 144 KM/H durante 5 minutos y luego nos detiene la
       policia durante unos 25 minutos. Al finalizar el regano, tomamos nue-
       stro portatil 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
       pondrian una multa, solo que no por exceso de velocidad.

       Obviamente, en este caso, no deberiamos tomar en cuenta los promedios.
       Estos son utiles en varios casos. Por ejemplo, si queremos ver cuantos
       KM hemos viajado, este seria el grafico mas indicado. Pero por otro
       lado, para ver la velocidad ha la que hemos viajado, los valores
       maximos son mas 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
       maximos. Con el tiempo, ambas cantidades se separan cada vez mas.  En
       la ultima base de datos que creamos, habia dos archivos que guardaban
       los datos de cada dia. El archivo que guarda los promedios mostrara
       valores bajos, mientras que el de maximos mostrara valores mas altos.
       Para mi coche, mostraria valores promedio de 96/24=4 KM/H (viajo unos
       96 kilometros por dia), y maximos de 1220 KM/H (la velocidad maxima que
       alcanzo cada dia)

       Como ves, una gran diferencia. No mires el segundo grafico para estimar
       la distancia que recorro, ni al primero para estimar la velocidad a la
       que voy. Esto solo 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 grafico subira a unos 60 KM/H.
       El segundo mostrara unos 180 KM/H. Esto significa que recorri unos 60
       KM/H por 24 horas = 1440 KM. Muestra ademas que fui a una velocidad
       promedio mayor a la normal y a un maximo 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 cafe de vez en cuando, manejar mas lentamente por Austria y
       Holanda, e ir con cuidado en las montanas y las villas. Si vieramos los
       graficos de los promedios de cada 5 minutos, la imagen seria completa-
       mente distinta; veriamos los mismos valores de promedio y de maxima.
       (suponiendo que las mediciones fueran cada 300 segundos). Se podria ver
       cuando pare, cuando iba en primera, cuando iba por las autopistas, etc.
       La granularidad de los datos es mas alta, por lo que se tiene mas
       informacion. Sin embargo, esto nos lleva unas 12 muestras por hora, o
       288 al dia, lo cual es mucho para guardar por un periodo de tiempo
       largo. Por lo tanto, sacamos el promedio, guardando eventualmente un
       solo valor por dia.  Con este unico valor, no podemos ver mucho.

       Es importante comprender lo que expuesto en estos ultimos parrafos.
       Unos ejes y unas lineas no tienen ningun valor por si mismos; hay que
       saber que representan e interpretar correctamente los valores
       obtenidos. Sean cuales sean los datos, esto siempre sera 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 grafico
       alguno.

       RReeppaasseemmooss lloo qquuee ssaabbeemmooss

       Ahora ya sabes como crear una base de datos. Puedes guardar valores en
       ella, extraerlos creando un grafico, hacer operaciones matematicas 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 maximos y cuando debemos usar cada uno (o al menos una idea de
       ello)

       RRDtool puede hacer mas 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.  Asegurate de
       entenderlo todo. El esfuerzo valdra la pena, y te ayudara, no solo con
       el resto del documento, sino en tu trabajo diario de monitorizacion,
       mucho despues de terminar con esta introduccion.

       TTiippooss ddee ffuueenntteess ddee ddaattooss

       De acuerdo, quieres continuar. Bienvenido de vuelta otra vez y
       preparate; voy a ir mas rapido con los ejemplos y explicaciones.

       Ya vimos que, para ver el cambio de un contador a lo largo del tiempo,
       tenemos que tomar dos numeros y dividir la diferencia entre el tiempo
       transcurrido entre las mediciones. Para los ejemplos que hemos visto es
       lo logico, 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 ventilacion. Estos
       valores no son contadores; si tomo los valores de dos muestreos y lo
       divido entre 300 segundos, obtendre el cambio de temperatura por
       segundo. ?Esperemos que sea cero, o tendriamos 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 asi, pero se aproxima
       bastante a la verdad). Asi, los graficos se veran mucho mejor. Puedo
       ver cuando el enrutador esta trabajando mas (en serio, funciona; como
       usa mas electricidad, genera mas 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 el la cuenta. Por ejemplo, nuestro primer ejemplo, (12345,
       12357, 12363, 12363), seria (unknown, 12, 6, 0) en ABSOLUTE.  El otro
       tipo, DERIVE, es como COUNTER, pero al contrario de COUNTER, este valor
       tambien 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"

       RRRRDDttooooll bbaajjoo eell mmiiccrroossccooppiioo


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

       ?   La linea B es de tipo GAUGE. Estos son los valores "reales", asi
           que el grafico debe mostrar lo mismo que los valores que introduci-
           mos: una especie de onda

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

       ?   La linea D es de tipo ABSOLUTE. Esto es, es un contador pero no hay
           que calcular las diferencias. Los numeros son iguales a la linea A,
           y espero que puedas ver la diferencia en los graficos.

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

        - Linea  A:  u  u  1  1  1  1  1  1  1  1  1  u
        - Linea  B:  u  1  3  5  3  1  2  4  6  4  2  u
        - Linea  C:  u  u  2  2  2  0 -2 -6  2  0  2  u
        - Linea  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 esta funcionando bien, el visor de graficos
       no te engana y hemos entrado en el 2000 sin problemas :) Puedes probar
       el mismo ejemplo cuatro veces, una por cada linea.

       Revisemos los datos otra vez:

       ?   Linea 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 que 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
           teniamos un valor inicial para calcular la diferencia. Seria un
           error asumir que el contador empezaba en 0, asi que no conocemos el
           valor de la diferencia

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

       ?   Linea C: De nuevo, no conocemos el valor inicial antes de la
           primera medicion, asi que se aplica el mismo razonamiento que para
           la linea A. En este caso las diferencias no son constantes, asi que
           la linea no es recta. Si hubiesemos puesto los mismos valores que
           en la linea A, el grafico seria el mismo. Al contrario que COUNTER,
           el valor puede decrecer, y espero mostrarte mas adelante el por que
           de la diferencia entre ambos tipos.

       ?   Linea D: En este caso, el dispositivo nos da las diferencias por si
           mismo. Por lo tanto, conocemos la diferencia inicial, y podemos
           graficarla. Tenemos los mismos valores que en la linea A, pero su
           significado es distinto, por lo que el grafico tambien 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 division nos da resultados cada vez mayores.

       RReeiinniicciiaalliizzaacciioonn ddee llooss ccoonnttaaddoorreess

       Todavia nos quedan algunas cosas por ver. Nos quedan algunas opciones
       importantes por cubrir, y aun no hemos hablado de la reinicializacion
       de contadores. Empecemos por ahi: Estamos en nuestro coche, vemos el
       contador y muestra 999987. Andamos unos 20 KM, asi que el contador debe
       subir a 1000007. Desafortunadamente, el contador solo tiene 6 digitos,
       asi que en realidad nos muestra 000007. Si estuvieramos guardando los
       valores en un tipo DERIVE, esto significaria que el contador retrocedio
       unos 999980 KM. Por supuesto esto no es cierto, por lo que necesitamos
       alguna proteccion contra estos casos. Esta proteccion solo la tenemos
       para el tipo COUNTER, el cual de todas formas era el que teniamos que
       haber usado para este tipo de contador. ?Como 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 maximo del contador + 1. Para
       nuestro coche, tendriamos:

        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 tamano. 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
       maximo del contador "menor" (32 bits) + 1 a la diferencia. Si aun asi
       la diferencia es negativa, entonces el contador reinicializado era
       mayor (64 bits), por lo que se le suma el valor maximo del contador
       "largo" + 1 y se le resta el maximo del contador "pequeno" que sumamos
       erroneamente. Hay un problema con esto: supongamos que un contador
       largo se ha reinicializado al sumarsele una diferencia muy grande;
       entonces es posible que al anadir el valor maximo del contador pequeno
       la diferencia nos de 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 maximo del contador, por lo
       que de ocurrir es muy probable que halla varios problemas mas en la
       configuracion y no merezca la pena preocuparse solo por este. Aun asi,
       he incluido un ejemplo de este caso para que lo puedas juzgar por ti
       mismo.

       A continuacion, unos ejemplos de reinicializacion de los contadores.
       Prueba de hacer los calculos por ti mismo, o acepta mis resultados si
       tu calculadora no puede con los numeros :)

       Numeros de correccion:

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

        Antes:          4294967200
        Incremento:            100
        Deberia ser:    4294967300
        Pero es:                 4
        Diferencia:    -4294967196
        Correccion #1: -4294967196 + 4294967296 = 100

        Antes:          18446744073709551000
        Incremento:                      800
        Deberia ser:    18446744073709551800
        Pero es:                         184
        Diferencia:    -18446744073709550816
        Correccion #1: -18446744073709550816 +4294967296 = -18446744069414583520
        Correccion #2: -18446744069414583520 +18446744069414584320 = 800

        Antes:          18446744073709551615 ( valor maximo )
        Incremento:     18446744069414584320 ( incremento absurdo,
        Deberia ser:    36893488143124135935   minimo para que
        Pero es:        18446744069414584319   funcione el ejemplo)
        Diferencia:              -4294967296
        Correccion #1:  -4294967296 + 4294967296 = 0 (positivo,
                                                      por tanto no se hace
                                                      la segunda correccion)

        Antes:          18446744073709551615 ( valor maximo )
        Incremento:     18446744069414584319
        Deberia ser:    36893488143124135934
        Pero es:        18446744069414584318
        Diferencia:              -4294967297
        Correccion #1:  -4294967297 +4294967296 = -1
        Correccion #2:  -1 +18446744069414584320 = 18446744069414584319

       Como puede verse en los ultimos ejemplos, necesitas unos valores bas-
       tante extranos para hacer que RRDtool falle (asumiendo que no tenga
       ningun error el programa, por supuesto), asi que esto no deberia ocur-
       rir. Sin embargo, SNMP o cualquier otro metodo que uses de recogida de
       datos puede tambien reportar algun valor erroneo ocasionalmente. No
       podemos prevenir todos los errores, pero podemos tomar algunas medidas.
       El comando "create" de RRDtool tiene dos parametros especialmente para
       esto, que definen los valores minimo y maximo permitidos. Hasta ahora
       hemos usado "U", "desconocido". Si le pasas valores para uno o ambos
       parametros y RRDtool recibe un valor fuera de esos limites, los igno-
       rara. Para un termometro en grados Celsius, el minimo absoluto es -273.
       Para mi enrutador, puedo asumir que ese minimo es mucho mayor, digamos
       que 10.  La temperatura maxima la pondria en unos 80 grados; mas alto y
       el aparato no funcionaria. Para mi coche, nunca esperaria obtener val-
       ores negativos, y tampoco esperaria valores mayores a 230.  Cualquier
       otra cosa seria 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 grafico si los valores parecen extranos.

       RReemmuueessttrreeoo ddee llooss ddaattooss

       Hay una funcionalidad importante de RRDtool que no hemos explicado
       todavia: 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 aqui la ayuda que necesitas:

       Supongamos un contador se incremente exactamente en 1 cada segundo.
       Queremos medirlo cada 300 segundos, por lo que deberiamos tener valores
       separados exactamente en 300. Sin embargo, por varias circunstancias
       llegamos unos segundos tarde y el intervalo es 303. La diferencia sera
       por tanto 303. Obviamente, RRDtool no debe colocar 303 en la base de
       datos y dar asi la impresion de que el contador se incremento 303 en
       300 segundos. Aqui es donde RRDtool interpola: altera el valor 303 al
       valor que tendria 3 segundos antes y guarda 300 en 300 segundos. Dig-
       amos que la proxima vez llegamos justo a tiempo; por tanto, el inter-
       valo actual es 297 segundos, por lo que el contador deberia 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 identicas. 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 se :)

          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 graficos debe ser iguales.

RREESSUUMMEENN
       Es hora de concluir este documento. Ahora debes conocer lo basico como
       para trabajar con RRDtool y leer la documentacion. Aun hay mucho mas
       por descubrir acerca de RRDtool, y le encontraras; mas y mas usos para
       la herramienta. Con los ejemplos y la herramienta puedes crear facil-
       mente muchos graficos; tambien puedes usar las interfaces disponibles.

LLIISSTTAA DDEE CCOORRRREEOO
       Recuerda subscribirte a la lista de correo. Aunque no contestes los
       correos que aparecen en ella, te servira de ayuda a ti y a los demas.
       Mucho de lo que se sobre MRTG (y por tanto sobre RRDtool), lo aprendi
       tan solo con leer la lista, sin escribir. No hay por que preguntar las
       preguntas basicas, que ya tienen su respuesta en la FAQ (?leela!). Con
       miles de usuarios a lo largo del mundo, siempre hay preguntas que tu
       puedes responder con lo aprendido en este y otros documentos.

VVEERR TTAAMMBBIIEENN
       Las paginas del manual de RRDtool

AAUUTTOORR
       Espero que hayas disfrutado con los ejemplos y las descripciones.  Si
       es asi, ayuda a otros refiriendolos a este documento cuando te hagan
       preguntas basicas. No solo obtendran la respuesta, sino que aprenderan
       muchas otras cosas.

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



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