<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Carlos Peñas on Medium]]></title>
        <description><![CDATA[Stories by Carlos Peñas on Medium]]></description>
        <link>https://medium.com/@theistian?source=rss-e1875729aaea------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*05VaUxkj8ibHGpjqJ07PSA.jpeg</url>
            <title>Stories by Carlos Peñas on Medium</title>
            <link>https://medium.com/@theistian?source=rss-e1875729aaea------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 22:24:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@theistian/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Telemetría en aplicación ruby con telegraf]]></title>
            <link>https://medium.com/the-cocktail-engineering/telemetr%C3%ADa-en-aplicaci%C3%B3n-ruby-con-telegraf-9cd64808828c?source=rss-e1875729aaea------2</link>
            <guid isPermaLink="false">https://medium.com/p/9cd64808828c</guid>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[influxdb]]></category>
            <category><![CDATA[monitoring]]></category>
            <category><![CDATA[statsd]]></category>
            <dc:creator><![CDATA[Carlos Peñas]]></dc:creator>
            <pubDate>Mon, 29 May 2017 07:42:10 GMT</pubDate>
            <atom:updated>2017-05-29T07:42:10.783Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-Hf1J_jcwex3s5yXBeke5g.jpeg" /><figcaption>Aereogeneradores. La Muela, Zaragoza</figcaption></figure><p>Prueba de concepto práctica sobre cómo <strong>monitorizar</strong> el comportamiento de un webservice externo (simulado) de una aplicación <strong>Ruby</strong>, mediante el protocolo de <strong>StatsD</strong> con almacenamiento en <strong>InfluxDB</strong> y visualización en <strong>Grafana</strong>.</p><p>Ya ha llovido bastante desde que, en 2011, Etsy nos sacudiera con su post “<a href="https://codeascraft.com/2011/02/15/measure-anything-measure-everything/">Measure Anything, Measure Everything</a>” presentando su uso de StatsD. Desde entonces StatsD es un protocolo tan sencillo que hay numerosas implementaciones. Una de ellas, la que describe este post, se encuentra integrada en Telegraf, una de las piezas habituales del stack de monitorización que usamos en The Cocktail. Aún con ello, hay varias versiones para todos los gustos de StatsD, por lo que al margen de los ejemplos, el resto se puede aplicar al stack favorito de cada cual.</p><h4>Recap: Qué es StatsD?</h4><p>StatsD fue un servidor de almacenamiento de estadísticas, desarrollado en Node por Etsy, pensado para recibir telemetría interna de aplicación. A grandes trazos es un programa que queda en memoria y memoriza los datos que le vayan llegando por UDP. ¡Ni siquiera está encargado de persistirlos o mostrarlos! Como servidor puede almacenar Gauges, Counters, Sets y Timers. Los Timers son interesantes, porque irán almacenando los tiempos que les digamos, calculando medias, máximas, mínimas y el percentil que queramos calcular.</p><h4>Configurar Telegraf para comportarse como StatsD</h4><p>StatsD además es un protocolo tan simple que ya no se usa el servidor desarrollado por Etsy, porque quien más quien menos ha desarrollado el protocolo como complemento a otro sistema. Es el caso de Telegraf. Telegraf puede configurarse como servidor de StatsD y los resultados de los diferentes intervalos se irán almacenando en InfluxDB conforme lleguen sus ciclos de actualización. Podemos elegir si queremos que los contadores se vacíen o no, tras cada ronda de almacenado.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7e680ca417c300c867d5828e4fd8cf20/href">https://medium.com/media/7e680ca417c300c867d5828e4fd8cf20/href</a></iframe><h4>La aplicación Sinatra a monitorizar</h4><p>Necesitamos una aplicación para monitorizar. Lo mas sencillo para el caso de prueba es tener una aplicación pequeña en <em>Sinatra</em> que simula mediante <em>sleep</em> una hipotética llamada a un servicio en red. Si el <em>sleep</em> se pasa de largo se genera un timeout, otras veces se simula un fallo de conexión y el resto de las ocasiones se realiza un <em>sleep </em>más o menos largo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a2885ddb6531823bc7d10c6ab69529e3/href">https://medium.com/media/a2885ddb6531823bc7d10c6ab69529e3/href</a></iframe><p>Para monitorizarla mediante StatsD necesitaremos la gema <a href="https://rubygems.org/gems/statsd-ruby">statsd-ruby</a> y tendremos que incluir código para crear nuestra conexión (que no es tal al tratarse de UDP) en Sinatra en el bloque de configuración. Usamos variables de entorno por aquello de los <a href="https://12factor.net/es/config">12 factores</a> y porque el plan es que funcione dentro de un contenedor Docker.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f818900e79565934f25f128726181af6/href">https://medium.com/media/f818900e79565934f25f128726181af6/href</a></iframe><p>Recuperando ese objeto cliente desde las settings podremos usarlo para incrementar un valor, alterar un gauge o, lo más interesante de todo, encerrar un bloque de código en una invocación del método <em>time</em>, que realizará un cálculo de tiempo y lo enviará a StatsD</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c66a66fe4d3c62a85b9dd7b3ee1f4ec4/href">https://medium.com/media/c66a66fe4d3c62a85b9dd7b3ee1f4ec4/href</a></iframe><p>La aplicación completa con código de monitorización se puede ver <a href="https://github.com/theist/blog-telemetry/blob/master/sinatest/app.rb">aquí</a>.</p><h4>Datos interesantes para mostrar en Grafana</h4><p>Tras generar varias llamadas a StatsD en el almacén de datos de InfluxDB (en los ejemplos presentados) se habrán generado nuevos <em>measurements </em>en la base de datos <em>telegraf</em>. Dichos datos serán</p><pre>error_connect: un campo value con la cuenta acumulada en intervalo de 10 segundos de los errores de conexión</pre><pre>error_timeout: un campo value con la cuenta acumulada en intervalo de 10 segundos de los errores por timeout</pre><pre>foobar_value: un campo value con la suma acumulada en intervalos de 10 segundos del valor de foobar</pre><pre>execution_time: Varios campos con: el número, la media de tiempo, el tiempo máximo y mínimo, el percentil 90 y la desviación estándar de todos los tiempos que hayamos enviado a statsD en el mismo intervalo de 10 segundos</pre><h4>Demo: Lanzar el stack</h4><p>He dejado todo lo necesario para lanzar todos los componentes y sus relaciones a día de hoy la aplicación en un sistema dotado de docker y docker-compose en este repositorio:</p><p><a href="https://github.com/theist/blog-telemetry">theist/blog-telemetry</a></p><p>Mediante la orden <strong><em>docker-compose up</em></strong> se lanzarán todos los contenedores de aplicación necesarios y se relacionan para que se puedan comunicar internamente. Son, el contenedor de Telegraf con su configuración para StatsD escuchando en el puerto 8125; el contenedor de InfluxDB escuchando en el puerto 8083 y 8086 y el contenedor de Grafana escuchando en el puerto 3000. También se construirá un contenedor derivado de Ruby que incluirá y arrancará la aplicación final con el código para StatsD y que escucha en el puerto 4567.</p><h4>Demo: Generar trafico a nuestra app</h4><p>La aplicación de Grafana quedará recibiendo tráfico pero es necesario realizar peticiones para generar tráfico sobre la misma. Puede servirnos cualquier aplicación para generar peticiones HTTP. <em>curl</em>, <em>wget</em>, a mano mediante el navegador o <em>apache benchmark</em>. A mi me gusta <a href="https://github.com/tsenart/vegeta/releases/tag/v6.3.0"><em>vegeta</em></a>, una aplicación versátil y sencilla de manejar echa en Go y que funciona casi en cualquier lado con solo descargarla.</p><pre>echo “GET <a href="http://0.0.0.0:4567/">http://0.0.0.0:4567</a>&quot; | ./vegeta attack -duration=30m rate=3 | ./vegeta report</pre><p>Con <em>rate</em> y <em>duration </em>se puede controlar la cantidad de peticiones que se realizan</p><h4>Demo: Terminar de configurar Grafana</h4><p>El Grafana que viene en la demo no está terminado de configurar. Una vez arrancado se accede desde el navegador, en el servidor local en el <a href="http://localhost:3000/">puerto 3000</a> Tras esto hay que hacer login (admin/admin), crear un datasource con los siguientes datos</p><pre>Nombre: influx<br>Tipo: InfluxDB<br>URL: <a href="http://influx:8086/">http://influx:8086</a><br>Modo: proxy<br>Base de datos: telegraf</pre><p>Tras esto podremos importar el dashboard <a href="https://github.com/theist/blog-telemetry/blob/master/statsd_demo_dashboard.json">presente en el repositorio</a>, que ya viene preparado con las consultas adecuadas y que debería mostrar algo como esto, si la versión de Grafana no ha cambiado mucho</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/956/1*0D6TJC-qnqC_ZzxyExUHYA.png" /></figure><p>Y en el que se puede ver cuánto ha fallado la conexión por segundo, cuántos timeouts se están produciendo por segundo, la media y el percentil 90 del tiempo de respuesta del supuesto web service, y cuánto va acumulando el valor de “foo” todo ello en intervalos de 10 segundos (aunque esto puede resultar bastante estresante para la red de un site en producción).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9cd64808828c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-cocktail-engineering/telemetr%C3%ADa-en-aplicaci%C3%B3n-ruby-con-telegraf-9cd64808828c">Telemetría en aplicación ruby con telegraf</a> was originally published in <a href="https://medium.com/the-cocktail-engineering">The Cocktail Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Puente de Graphite a InfluxDB mediante Telegraf]]></title>
            <link>https://medium.com/the-cocktail-engineering/puente-de-graphite-a-influxdb-mediante-telegraf-404b847a8e02?source=rss-e1875729aaea------2</link>
            <guid isPermaLink="false">https://medium.com/p/404b847a8e02</guid>
            <category><![CDATA[monitoring]]></category>
            <category><![CDATA[influxdb]]></category>
            <category><![CDATA[graphite]]></category>
            <category><![CDATA[metrics]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Carlos Peñas]]></dc:creator>
            <pubDate>Wed, 22 Mar 2017 08:54:32 GMT</pubDate>
            <atom:updated>2017-03-22T08:54:33.352Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dgV_wlTs80TRl2LpgyqF0g.jpeg" /><figcaption>Muel, Zaragoza</figcaption></figure><p>(para sitespeed.io)</p><p>Sitespeed.io es una de esas aplicaciones que aparecen de vez en cuando y que son muy versátiles. Realiza toda una serie de métricas del proceso de carga de una web y las presenta en unos prácticos HTML o en un sumario al final de la ejecución. Además todo ello impecablemente empaquetado en una imagen de Docker lista para usar sin software adicional. Sólo así es una herramienta a la que merece la pena dedicar un rato. ¡Pero es que además entrega métricas! Ahí es donde la imaginación se dispara… y el globo se pincha cuando te das cuenta que entrega métricas para otra base de datos que no usas.</p><p>Así es, <a href="http://sitespeed.io/">sitespeed.io</a> entrega un puñado de métricas a un servidor de Carbon, que es parte de <a href="https://graphite.readthedocs.io/en/latest/">Graphite</a>, pero revisando el proyecto hay un rayo de esperanza; están trabajando en dar soporte a InfluxDB. ¿Pero quién quiere esperar en la aburrida carretera de las releases si puedes tomar un atajo y además divertirte en el proceso?</p><p><a href="https://github.com/sitespeedio/sitespeed.io/issues/889">InfluxDB support · Issue #889 · sitespeedio/sitespeed.io</a></p><h4>Servicio de ingestión de métricas de Graphite para InfluxDB.</h4><p>Revisando la documentación sitespeed.io no soporta InfluxDB directamente pero si es cierto que <a href="http://InfluxDB puede levantar un puerto TCP y escuchar en el metricas de graphite">InfluxDB puede levantar un puerto TCP y escuchar en él métricas de Graphite</a> y mediante unas plantillas transformarlo en métricas adecuadas para InfluxDB. Este método sirve tanto para sitespeed.io, sobre el que están todos los ejemplos o para cualquier otro sistema en el que necesitemos trasladar la salida de Graphite a InfluxDB.</p><h4>Hands On!</h4><p>Trabajar directamente sobre InfluxDB no resulta muy óptimo. Afortunadamente Telegraf soporta también el mismo juego de plantillas para una entrada y en vez de tirar los datos sobre InfluxDB podemos ir viendo sobre la salida estándar de Telegraf una vez procesado para que sea válido para InfluxDB</p><p>Las métricas que se le entregan a Graphite tienen este aspecto:</p><pre>&lt;field&gt;.&lt;field&gt;.&lt;field&gt;.&lt;field&gt;.&lt;field&gt; &lt;value&gt; &lt;time&gt;</pre><p>Los campos llevan información totalmente posicional, es decir significan una cosa u otra dependiendo de la posición que ocupan en el identificador de la métrica. Eso funciona con el lenguaje de consultas de Graphite, pero no vale para el pseudo SQL de InfluxDB. Si se trasladan “sin más” a InfluxDB se creará una <em>measurement</em> por cada nombre. El proceso consiste en determinar qué tiene que ser un nombre, qué tiene que ser un <em>tag</em> y qué tiene que ser el valor (el tiempo, claro, no hay que tocarlo)</p><p>Empezamos con una configuración de Telegraf que nos permita ver las métricas que se envían, usando una configuración que presente las llamadas a InfluxDB por la salida estándar.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/880489e6953c77eaa7ca7d47b5c3188c/href">https://medium.com/media/880489e6953c77eaa7ca7d47b5c3188c/href</a></iframe><p>Arrancamos Telegraf con esa configuración usando la imagen oficial de Docker:</p><pre>docker run -ti --rm --name telegraf -v $PWD/plain.conf:/etc/telegraf/telegraf.conf telegraf</pre><p>Y lanzamos sitespeed io, indicándole que debe usar el host <em>telegraf</em> como si fuera un servidor de Graphite.</p><pre>docker run --privileged --shm-size=512m --link telegraf --rm sitespeedio/sitespeed.io <a href="https://the-cocktail.com/">https://the-cocktail.com</a> --graphite.host telegraf</pre><p>En la salida del contenedor de Telegraf veremos, en cuanto la ronda de sitespeed termine, un listado con todas las métricas que el contenedor de sitespeed.io habría entregado en Graphite pero con una primera transformación para convertirlas en métricas de Graphite consistente en transformar todo el identificador de la métrica en Graphite en una <em>measurement</em> de influx, con un único valor <em>value</em>.</p><h4>Plantillas</h4><p>Tal y como están nos sirve mas bien de poco. Dos urls distintas darían measurements distintas y se nos complicaría compararlas.</p><p>Las plantillas de transformación de Graphite a InfluxDB tienen principalmente dos partes: el filtro y la plantilla. El filtro decide si la plantilla se aplica (o no) a una entrada y la plantilla hace la transformación. Los filtros se aplican según el orden indicado, el primero que coincide. Es decir, que si dos filtros son validos para una expresión se aplicará el primero que esté definido.</p><p>En el filtro podemos usar caracteres literales, que deberán coincidir con los campos y asteriscos que se emparejarán con cualquier secuencia de caracteres. Las separaciones entre campos (los puntos) deberán coincidir a no ser que se termine el filtro con un asterisco, que abarca el resto de la métrica.</p><p>Para la plantilla podemos usar:</p><pre>..          -&gt; El campo de la medida de graphite se ignorará<br>measurement -&gt; El campo será parte del nombre de la métrica<br>field       -&gt; El campo formará parte del nombre del valor, de no<br>               estar presente se tomará &quot;value&quot;<br>otra cadena -&gt; El campo e convertirá en un tag con el nombre elegido<br>               y el valor que ocupa el campo</pre><p>Por ejemplo:</p><pre>&quot;sitespeed_io.default.pageSummary.*.*.*.*.coach.advice.*.score ...url.url.browser.connection.measurement..field.measurement&quot;</pre><p>Generará las siguientes métricas de InfluxDB:</p><pre>coach_score,connection=native,url=the-cocktail_com__,browser=chrome performance=54 -time-</pre><pre>coach_score,browser=chrome,connection=native,url=the-cocktail_com__ bestpractice=94 -time-</pre><pre>coach_score,url=the-cocktail_com__,browser=chrome,connection=native accessibility=71 -time-</pre><p>Lo que nos permitiría realizar comparaciones o agregaciones entre distintos navegadores o urls.</p><h4>Ship It!</h4><p>Queda por delante un buen trabajo de selección de métricas <a href="https://gist.github.com/theist/2ccfc699d1792495d7140244b18f1314">hasta que demos con el set de medidas que queremos guardar y cómo</a>. Lo mejor de todo, una vez finalizado no tenemos que deshacernos de Telegraf ya que podemos usarlo para dar salida a las métricas transformadas. Ello nos incrementará la seguridad, ya que por defecto Carbon no cifra el tráfico ni soporta autenticación, pero si podemos establecer esos dos mecanismos entre Telegraf e InfluxDB quedándose la comunicación insegura sólo entre nuestros contenedores.</p><p>Así pues necesitaremos un contenedor con Telegraf y un sistema que nos vaya lanzando periódicamente contenedores de sitespeed.io, para montarnos un sistema que, no solo analiza puntualmente el rendimiento, si no que además permite mantener un histórico para ver su progreso, por ejemplo mediante un sencillo dashboard en Grafana:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b5uk14J-U7hz0Coc06gUKw.png" /></figure><h4>Configuración con filtros y plantillas</h4><p>Este es un ejemplo razonablemente completo para el caso de pedirle a Sitespeed una única url. En general separa la url, navegador y conexion usadas como tags, separa las diferentes estadisticas como tags tambien y el resto depende un poco de lo que nos ha ido pareciendo adecuado.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5a056f94ee47efeedb983fa40c7de3d9/href">https://medium.com/media/5a056f94ee47efeedb983fa40c7de3d9/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=404b847a8e02" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-cocktail-engineering/puente-de-graphite-a-influxdb-mediante-telegraf-404b847a8e02">Puente de Graphite a InfluxDB mediante Telegraf</a> was originally published in <a href="https://medium.com/the-cocktail-engineering">The Cocktail Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Análisis de datos de monitorización en InfluxDB con Python]]></title>
            <link>https://medium.com/the-cocktail-engineering/analisis-de-datos-de-monitorizacion-en-influxdb-con-python-9e1f727a90a4?source=rss-e1875729aaea------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e1f727a90a4</guid>
            <category><![CDATA[influxdb]]></category>
            <category><![CDATA[statistics]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[monitoring]]></category>
            <dc:creator><![CDATA[Carlos Peñas]]></dc:creator>
            <pubDate>Wed, 28 Dec 2016 07:47:01 GMT</pubDate>
            <atom:updated>2016-12-28T07:47:01.718Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m9b0IcPvYipwJY6AsfBCKw.jpeg" /></figure><p>Mucho ha llovido desde los años en los que Nagios era el rey del gallinero. Hoy en día hay varios stacks que suplen todas sus funciones en mayor o menor medida, aunque cuesta encontrar algo que lo haga TODO como el viejo Nagios.</p><p>Poco a poco en The Cocktail hemos ido basculando hacia un stack de monitorización basado en <em>InfluxDB</em>, <em>Kapacitor</em>, <em>Telegraf</em> y <em>Grafana</em>. Si bien los resultados a nivel de visualización, alerting y transporte de métricas son razonablemente buenos, hay algo que siempre he echado en falta: el cálculo del Nivel de Servicio para un servicio en concreto. Pero los datos están ahí, sólo hay que saber cómo leerlos y visualizarlos. SysAdmin meets Data!</p><p>Todas las pruebas de este artículo se ha realizado con Python 3, sobre un <a href="http://jupyter.org/">jupyter notebook</a> usando los paquetes de python: <a href="https://github.com/influxdata/influxdb-python"><em>influxdb</em></a>, <a href="http://matplotlib.org/"><em>matplotlib</em></a> y <a href="http://pandas.pydata.org/"><em>pandas</em></a> como parte del código y con <em>jupyter</em>, <em>notebook</em> y <em>qtconsole</em> como interfaz. Todos ellos y sus dependencias son instalables via <em>PIP</em>.</p><p>El notebook estático renderizado con todo el código (y algo más) de los ejemplos puede verse en un jupyter notebook estático en <a href="https://gist.github.com/theist/0bea371b368271423dc19d9fd19277e1">https://gist.github.com/theist/0bea371b368271423dc19d9fd19277e1</a> y está adjunto al final del artículo</p><h4>Conectar y extraer datos.</h4><p><em>InfluxDB</em> es una Time Series Database, por lo que hace lo que su nombre indica, guardar series de datos indexadas por tiempo. Además provee una API que nos permite realizar consultas por un interfaz REST. Es factible conectarse con el módulo requests de Python y sacar datos en formato JSON, pero afortunadamente <strong><em>influxdata</em></strong>, desarrolladores de <em>InfluxDB</em>, ya han pensado en ello y existe una librería de cliente, <a href="http://influxdb-python.readthedocs.io/en/latest/api-documentation.html"><em>influxdb-client</em></a><em>,</em> que facilita realizar consultas a <em>InfluxDB</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c6982744c1f30e6a9c34ae7dbfc0f9e6/href">https://medium.com/media/c6982744c1f30e6a9c34ae7dbfc0f9e6/href</a></iframe><p>Este código se conectaria un <em>InfluxDB</em> en local, usando SSL y usuario y contraseña y obtendría un ResultSet parecido a este, dependiendo de las series de datos presentes en el sistema:</p><pre>ResultSet({&#39;(&#39;databases&#39;, None)&#39;: [{&#39;name&#39;: &#39;_internal&#39;}, {&#39;name&#39;: &#39;telegraf&#39;}, {&#39;name&#39;: &#39;events&#39;},{&#39;name&#39;: &#39;alerts&#39;}]})</pre><h4>Conocer el contenido de InfluxDB</h4><p>Hay un puñado de queries claves para moverse dentro de un <em>InfluxDB</em>, que son: las indicadas para saber qué bases de datos existen, qué medidas hay almacenadas en cada base de datos, de qué tags disponen dichas medidas y cuáles son las posibles variaciones para determinado tag en determinada medida por las que podemos filtrar o agrupar.</p><p>Por comodidad con el cliente ya definido y sabiendo que siempre vamos a usar la misma base de datos podemos crearnos un puñado de funciones que nos devuelvan los resultados de estas queries de la siguiente forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/43e0afe51b8004ccc5702ee491911881/href">https://medium.com/media/43e0afe51b8004ccc5702ee491911881/href</a></iframe><p>De este modo, en nuestra consola interactiva, cada vez que queramos saber si determinada combinación de tags y valores es válida para cierta medida no tenemos que recordar la consulta o acudir al interfaz de <em>InfluxDB</em>.</p><h4>Science!</h4><p>Ya estamos en disposición de empezar a analizar números y series de nuestro <em>influxDB</em> usando como herramienta <em>pandas</em>, una potente librería de manipulación estadística.</p><p>Primero obtenemos de <em>InfluxDB</em> la serie con la que queramos trabajar. Hemos elegido un conjunto de datos real del número de trabajos procesados por un sistema <em>sidekiq</em>, sólo porque su aspecto nos viene bien para poder trabajar con estados de ALERTA / OK después.</p><p>Esta serie en concreto proviene de un contador (es decir que crece constantemente). Siendo así no nos vale de mucho ya que nos interesa el incremento así que le pediremos <em>InfluxDB</em> que nos calcule la derivada no negativa, en vez de calcularla con python.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8798aa6ddbb1b6b75b13c1c83520d93e/href">https://medium.com/media/8798aa6ddbb1b6b75b13c1c83520d93e/href</a></iframe><p>La variable foo contendrá una “Serie” de la librería <em>pandas</em> con la que podemos hacer toda suerte de manipulaciones y análisis.</p><pre>foo.describe([.25,.50,.75,.95])</pre><pre>count    43076.000000<br>mean        13.439211<br>std         26.670512<br>min          0.066667<br>25%          4.866667<br>50%          6.666667<br>75%          9.600000<br>95%         66.025000<br>max        316.250000<br>dtype: float64</pre><p>Incluido dibujarla si tenemos activada la visualización en linea (en jupyter qtconsole o jupyter notebook).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/533/1*0vVn5hPkdaRKR-DbLzYvwQ.png" /></figure><p>Tampoco es que la visualización sea nuestra meta final, de hecho <em>Grafana</em> hace ese trabajo muchísimo mejor que <em>pandas</em>, ya que los gráficos generados por <em>matplotlib</em> en principio son estáticos.</p><p>Supongamos que en nuestro sistema se considera que si el número de procesos supera los 100 por segundo estamos ante una condición de alerta. Con la serie generada podemos calcular cuándo fue la última vez que el valor superó 100 y por tanto cuánto tiempo ha pasado desde entonces. Obtendríamos el tiempo que ha transcurrido desde el final de la última situación de alerta y por tanto el tiempo que llevamos en estado OK, y podemos calcular análogamente cuando fue la última vez que el valor no superó 100, para hacer el mismo cálculo pero para estado de ALERTA. Uno de los dos cálculos arrojará 0 segundos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/afe3a6b961192f84873cb44afb1b969f/href">https://medium.com/media/afe3a6b961192f84873cb44afb1b969f/href</a></iframe><p>Ya tenemos una pareja de datos interesantes que indican el tiempo que llevamos en OK o en ALERTA. Para el calculo del tiempo total de ALERTA y del nivel de servicio necesitaremos un DataFrame de <em>pandas</em>, que vienen a ser varias series indexadas. Nos apoyaremos en dos columnas auxiliares que crearemos a partir de los datos de la serie.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/87c28b4ec1fd2b61d75cccf503c3eabd/href">https://medium.com/media/87c28b4ec1fd2b61d75cccf503c3eabd/href</a></iframe><p>Tras esto bar contiene una serie de tres columnas, el valor derivado proveniente de <em>InfluxDB</em>; una columna true o false dependiendo de si ese momento se podía considerar de alerta o no; y una columna que indica el tiempo transcurrido entre la celda anterior y la actual. Esta última coincide seguramente con el intervalo de monitorización, pero por ser estrictos hay que calcularla ya que de lo contrario estamos asumiendo que nunca hubo un retraso en la toma de la medida ni que la situación de la red o un ajuste de reloj de la máquina afectaron a ese intervalo.</p><p>Ya sólo las matemáticas nos separan de los valores que buscamos:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0f016e2d89ac62613a86784efbf10e06/href">https://medium.com/media/0f016e2d89ac62613a86784efbf10e06/href</a></iframe><p>Un poco de habilidad con <em>matplotlib</em> y un rato después podemos llegar a una representación visual que además recuerda bastante a los gráficos de servicio del añorado Nagios:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*vm_GqCpx0iXsLodBuXNyRg.png" /></figure><h4>Reutilizando lo aprendido</h4><p>Todo este análisis resulta bastante costoso de realizar por primera vez pero una vez realizado el código python se puede reaprovechar. Bien directamente en un notebook que cada vez que ejecutemos realice nuevamente los cálculos o mediante scripts que generen informes. Todo el cálculo además es perfectamente válido para cualquier consulta inicial de <em>InfluxDB</em> por lo que es sencillo alterar measurements o intervalos. El resto es determinar cómo calcular el estado de ALERTA / OK.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bd793a4addce0a6fe6fb913faa622954/href">https://medium.com/media/bd793a4addce0a6fe6fb913faa622954/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e1f727a90a4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-cocktail-engineering/analisis-de-datos-de-monitorizacion-en-influxdb-con-python-9e1f727a90a4">Análisis de datos de monitorización en InfluxDB con Python</a> was originally published in <a href="https://medium.com/the-cocktail-engineering">The Cocktail Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Verificar el comportamiento HTTP con RSpec]]></title>
            <link>https://medium.com/the-cocktail-engineering/verificar-el-comportamiento-http-con-rspec-efa99c007075?source=rss-e1875729aaea------2</link>
            <guid isPermaLink="false">https://medium.com/p/efa99c007075</guid>
            <category><![CDATA[sysadmin]]></category>
            <category><![CDATA[https]]></category>
            <category><![CDATA[rspec]]></category>
            <dc:creator><![CDATA[Carlos Peñas]]></dc:creator>
            <pubDate>Fri, 28 Oct 2016 16:29:19 GMT</pubDate>
            <atom:updated>2016-10-28T16:29:19.418Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wo6UtWysDpyQZxqGgqWeKQ.jpeg" /></figure><p>Suele suceder con frecuencia cuando se está renovando una web que nos interesa no perder los enlaces del tráfico del antiguo site, por motivos de indexabilidad en buscadores. Y eso suele hacer que los profesionales que revisan la estrategia SEO de los sites envíen una o varias versiones de mapas de redirecciones a aplicar en las aplicaciones o servidores. También pasa (sobre todo si hay múltiples versiones del documento de redirecciones) que alguna redirección pueda entrar en conflicto con otra definida en alguna versión anterior.</p><p>Es muy fácil usar Ruby para comprobar de forma automática cualquier condición que nos apetezca, dentro de las posibilidades del protocolo HTTP.</p><h4>Tres módulos</h4><p>Para aplicar esta técnica se necesitan usar sólo tres módulos de Ruby:</p><p><strong>csv:</strong> Parte del <em>core</em> de Ruby. Permite cargar ficheros de tipo CSV. Sí, la mayoría de las veces los mapas suelen venir en hojas de cálculo enormes, pero suele ser fácil exportarlas a texto y procesarlas con este módulo como si fueran Arrays.</p><p><strong>RSpec</strong>: Un viejo conocido del mundillo del desarrollo de Ruby, y una de las alternativas más extendidas de TDD. La diferencia es que esta vez lo vamos a utilizar como herramienta de automatización de pruebas no referidas a código.</p><p><strong>excon</strong>: Es un cliente HTTP, de muchos que hay en Ruby. Su cometido es realizar peticiones, resolver temas como el cifrado y la obtención de datos mediante protocolo HTTP o HTTPS. ¿Y por qué excon? principalmente por necesitar un cliente HTTP que resuelva él sólo las conexiones SSL y porque conviene que no siga redirecciones. En <a href="https://docs.google.com/spreadsheets/u/1/d/1uS3UbQR6GaYsozaF5yQMLmkySY6TO42BIndr2hUW2L4/pub?hl=en&amp;hl=en&amp;output=html">esta tabla</a> hay una comparativa de distintos clientes HTTP de Ruby.</p><h4>Inicializar RSpec</h4><p>Necesitamos nuestro CSV, un directorio vacío e inicializar rspec mediante:</p><pre>rspec --init</pre><p>Hecho esto podemos editar un fichero <em>spec/check_redirects_spec.rb</em> y montar el esqueleto sobre el que trabajar.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d83ecf309293947c04329cd9ad732b13/href">https://medium.com/media/d83ecf309293947c04329cd9ad732b13/href</a></iframe><p>Con <em>csv</em> podemos manipular nuestro array como sea necesario (en nuestro caso sobraba la columna del encabezado, pero se podría necesitar todo un procesado previo dependiendo del origen del documento). Las rutas son relativas por lo que, según está escrito este código, <em>redirects.csv</em> debería estar en la raíz de nuestras specs.</p><p>Se configuran los valores que necesitemos para <em>excon</em> y para cada fila de nuestro CSV cargado tomamos la primera columna como origen y las segunda como destino.</p><h4>Chequeando el destino</h4><p>Uno de los tests básicos seria comprobar que el destino que nos han facilitado de verdad existe y da un código de estado 200.</p><p>Para ello tomamos la URL de destino y comprobamos que entrega un código de estado 200 OK</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0fc0acbf5060b15f207c4f0c0a6aebcd/href">https://medium.com/media/0fc0acbf5060b15f207c4f0c0a6aebcd/href</a></iframe><h4>Chequeando la redirección</h4><p>Después la otra parte del check sería comprobar que el servidor realiza la redirección, en este caso una redirección permanente y que el destino de esa redirección es el que debe. Para ello, además del estatus de la respuesta nos valdremos de las cabeceras, dado que una redirección siempre tiene que tener una cabecera location que nos indique el destino de la misma.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/495e91333dc8ccf6db3589a0140b008b/href">https://medium.com/media/495e91333dc8ccf6db3589a0140b008b/href</a></iframe><h4>Profit!</h4><p>Una vez hecho esto sólo lanzando rspec, comenzará, URL por URL a comprobar las tres condiciones que le hemos solicitado. Puede pegarse un buen rato, dado que lo que estamos haciendo son dos conexiones HTTP por cada redirección, pero al finalizar tendremos un informe detallado de cuántas redirecciones fallan y por qué lo hacen cuando fallan. Además rspec también puede guardarlo todo en un documento HTML fácilmente revisable mediante</p><pre>rspec -f h &gt; results.html</pre><h4>¿Y qué más puedo probar?</h4><p>Aplicando esta técnica la podemos aplicar a modelos todo lo complejos que sean necesarios. Por ejemplo, se puede comprobar si determinadas URLs están protegidas por determinadas cabeceras, si existe determinado texto en determinadas URLs, si determinadas conexiones atraviesan la caché o si son cacheables, si las cabeceras expires de determinadas URLs están como deben… En definitiva, podemos mecanizar el análisis de cualquier información que normalmente depuraríamos mirando el código o las cabeceras que entrega el servidor. Siempre, por supuesto, que sepamos qué queremos comprobar y cómo se comprueba.</p><p>También se pueden ir acumulando los ficheros con redirecciones antiguas y hacer specs para los que vayan llegando y así asegurarse de que ninguna nueva redirección está enmascarada por alguna de las anteriores, pero lógicamente en caso de conflicto sería necesario contactar con el experto en SEO porque estos tests no van a resolver los conflictos por sí mismos. Sin embargo resultan imprescindibles como herramienta para detectar de forma ágil regresiones en los cambios</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=efa99c007075" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-cocktail-engineering/verificar-el-comportamiento-http-con-rspec-efa99c007075">Verificar el comportamiento HTTP con RSpec</a> was originally published in <a href="https://medium.com/the-cocktail-engineering">The Cocktail Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Recoger métricas con Telegraf detrás de un firewall.]]></title>
            <link>https://medium.com/the-cocktail-engineering/recoger-m%C3%A9tricas-con-telegraf-detr%C3%A1s-de-un-firewall-377889b66a1?source=rss-e1875729aaea------2</link>
            <guid isPermaLink="false">https://medium.com/p/377889b66a1</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[influxdb]]></category>
            <category><![CDATA[sysadmin]]></category>
            <category><![CDATA[monitoring]]></category>
            <dc:creator><![CDATA[Carlos Peñas]]></dc:creator>
            <pubDate>Wed, 07 Sep 2016 10:26:40 GMT</pubDate>
            <atom:updated>2016-09-07T10:51:07.945Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wt0n3nrTCPrUqRDm1NVJxA.jpeg" /></figure><p>Monitorización, uno de los pilares básicos de cualquier sistema que deba estar produciendo, y uno de los aspectos que más se ha movido últimamente. Parece que de unos años a esta parte cualquier startup que se precie tiene su propia opinión e incluso su propia colección de herramientas con la que realizar dicha tarea.</p><p>Una de esas herramientas es <a href="https://influxdata.com/time-series-platform/telegraf/"><em>Telegraf</em></a>, que es parte del stack <em>TICK </em>de <a href="https://influxdata.com/"><strong>influxdata</strong></a>. Telegraf es un agente ligero de recolección de datos, escrito en Go, cuyo principal propósito es enviar telemetría del sistema o de la aplicación a <a href="https://influxdata.com/time-series-platform/influxdb/"><em>InfluxDB</em></a>. InfluxDB es una time series database, también de influxdata.</p><p>Para trabajar con InfluxDB, Telegraf necesita una conexión directa con el puerto de API de InfluxDB y muchas veces esto no es posible por topología de red o seguridad, bien en el sistema monitorizado o en el propio servidor de InfluxDB. Para solventar ese problema, como siempre, tendremos que buscar la manera de sacar la telemetría obtenida con Telegraf de las máquinas que no tengan conexión con el servidor de InfluxDB.</p><h4>Método tradicional: HAproxy</h4><p><em>HAproxy</em> o realmente cualquier otro proxy HTTP o HTTPS, como <em>Nginx</em>, es igualmente válido. Colocando un servidor HAproxy en un nodo que tenga acceso al servidor de InfluxDB podemos sacar la telemetría de los nodos que no pueden, ya que en esencia Telegraf e InfluxDB se comunican mediante HTTP.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/426/1*HDj3NcjTkQg-ZJ0z2rdCGg.png" /></figure><p>Este sería el diagrama, o se puede incluso usar el listener de HAproxy para hacer llegar a InfluxDB los datos del Telegraf local, como mejor convenga.</p><p>En caso de perder temporalmente conectividad con InfluxDB o con el proxy, el Telegraf que atraviesa el proxy empezaría a acumular métricas en su buffer, hasta que volviese a estar todo el camino disponible.</p><blockquote>Demo Time</blockquote><p>Los ficheros de configuración sugeridos están disponibles en un <a href="https://github.com/the-cocktail/blog_telegraf_proxied">repositorio de github</a></p><p>Se arranca un servidor de InfluxDB usando docker con la siguiente orden</p><pre>docker run --rm -ti -p 8086:8086 -p 8083:8083 --name influx influxdb</pre><p>Será un contenedor docker temporal para InfluxDB y sus datos, el objetivo es sólo poder pararlo y arrancarlo para probar el efecto que tiene en el comportamiento. El puerto 8083 es para el WebUI de InfluxDB y el 8086 para el puerto de API. Al parecer el UI de InfluxDB necesita acceso al puerto de API para realizar consultas</p><p>Se arranca el servidor de HAproxy en otro contenedor</p><pre>docker run --rm -ti -v $PWD/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro  -p 8186:8186 --name haproxy --link influx haproxy</pre><p>Se arranca un servicio local de Telegraf en primer plano con la siguiente orden y fichero de config (se puede usar una máquina con Telegraf instalado o directamente el binario extraído del paquete que ofrece influxdata)</p><pre>telegraf -config telegraf.conf</pre><h4>Método experimental: Probando código “futuro” de <em>Telegraf</em></h4><p>Realmente en muchas ocasiones lo que de verdad interesaría sería no tener que depender de un servicio externo y que el propio<em> </em>Telegraf pudiera de alguna forma realizar la labor de encadenarse entre agentes. A fecha de ésta publicación con Telegraf estable esto no es posible, pero existen un par de pull requests en GitHub sin mergear todavía en el código principal que podrían servir para dicho cometido</p><ul><li><a href="https://github.com/influxdata/telegraf/pull/1526">New Tcp Forwarder Output plugin. by tuier · Pull Request #1526 · influxdata/telegraf</a></li><li><a href="https://github.com/influxdata/telegraf/pull/1407">Add HTTP listener service input plugin by bagelswitch · Pull Request #1407 · influxdata/telegraf</a></li></ul><p>Antes hay que conseguir un Telegraf compilado con dichas PR introducidas que, gracias a Docker, Github y Go, es más sencillo de lo que parece.</p><p>En esencia consiste en obtener el código de Telegraf, dentro de una imagen docker oficial de golang, mergear ambas PR y construirnos una nueva versión de Telegraf con dicho código incluido.</p><p>Como es sencillo pero largo de explicar disponemos de una <a href="https://hub.docker.com/r/thecocktail/telegraf_builder/">imagen de docker</a> y un <a href="https://github.com/the-cocktail/telegraf_builder">repositorio asociado</a> que se puede usar para realizar esta compilación automáticamente (e investigar el proceso), con la ventaja de que genera binarios y paquetes RPM y DEB.</p><pre>docker run --rm -v $PWD:/tmp thecocktail/telegraf_builder</pre><h4>#1526 TCP-Forwarder-output + TCP-service-input</h4><p>La versión actual de Telegraf cuenta con un plugin que escucha en un puerto TCP cualquier entrada de datos, entre ellas las de tipo “influx” es decir protocolo de entrada de datos de la propia InfluxDB. <a href="https://github.com/influxdata/telegraf/pull/1526">Esta PR</a> dota a Telegraf de una salida de datos equivalente, de modo que en teoría podría ser usada para enviar los datos saltando de un telegraf a otro.</p><p>El Telegraf que hace de proxy puede ser la última versión estable, y tiene que contar con la siguiente sección:</p><pre>[[inputs.tcp_listener]]<br>  service_address = &quot;:8186&quot;<br>  allowed_pending_messages = 10000<br>  max_tcp_connections = 250<br>  data_format = &quot;influx&quot;</pre><p>El Telegraf que no tiene acceso directo tiene que ser nuestro Telegraf modificado y debe contar con la siguiente sección:</p><pre>[[outputs.tcp_forwarder]]<br>  server = &quot;&lt;poxy_ip&gt;:8186&quot;<br>  timeout = &quot;5s&quot;<br>  reconnect = false<br>  data_format = &quot;influx&quot;</pre><p>En el repositorio de ejemplos están las configuraciones completas así como todo lo necesario para realizar la prueba local en GNU/Linux.</p><p>Arrancando primero el proxy y después el modificado podemos comprobar que los valores de ambos Telegrafs llegan a InfluxDB (si está arrancado)</p><p><strong>Sin embargo</strong> hemos podido comprobar durante las pruebas que no es posible arrancar los servicios de Telegraf en el orden inverso y que además si se pierde la conexión TCP al proxy temporalmente, el servicio no trata de recuperarla. Lo que lo hace demasiado endeble todavía para un entorno de producción. Es normal, es código que no está aún probado y <a href="https://github.com/influxdata/telegraf/pull/1526#issuecomment-244597800">ya lo hemos comunicado</a> al autor del mismo.</p><h4>#1407 Normal Influx Output + HTTP Listener Service</h4><p>Toca evaluar <a href="https://github.com/influxdata/telegraf/pull/1407">la otra PR</a> que hemos añadido a Telegraf. En este caso el servicio que no cuenta con acceso directo puede ser el telegraf estable y el único cambio a realizar es que en la salida de InfluxDB indicaremos realmente una url y puerto del proxy.</p><p>En el caso del proxy si que tendremos que usar el Telegraf modificado con la siguiente sección de la configuración:</p><pre>[[inputs.http_listener]]<br>   service_address = &quot;:8186&quot;<br>   read_timeout = &quot;10s&quot;<br>   write_timeout = &quot;10s&quot;</pre><p>Esta vez el comportamiento es mucho más robusto. El sistema que no tiene acceso a InfluxDB puede arrancar antes, si no encuentra el proxy o si este se cae, empezará a acumular métricas en su buffer, recuperando la conexiones en cuanto el proxy esté disponible.</p><p>Una peculiaridad de este modelo que lo hace distinto al de HAproxy es que realmente no se está haciendo un proxy directo a InfluxDB, por lo que si el proxy pierde la conexión con InfluxDB entonces el buffer del proxy empieza a llenarse con las métricas pendientes propias <strong>y las de todos los servicios conectados al proxy </strong>ya que, con este esquema no hay una comunicación directa entre InfluxDB y los Telegraf de detrás del firewall.</p><p>El resultado en todos los casos es que las métricas llegan a InfluxDB listas para ser consultadas por cualquier UI gráfico o analizadas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/865/1*jUdznLO6Esd4Oi-y8C41NQ.png" /></figure><p><strong>update: </strong>Ha sido mergeada <a href="https://github.com/influxdata/telegraf/pull/1407#issuecomment-244968490">hoy</a> una PR que incluye el trabajo de la #1407 por lo que es presumible que el telegraf estable cuente pronto con la posibilidad de definir http listeners sin necesidad de andar recompilándolo<strong>.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=377889b66a1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-cocktail-engineering/recoger-m%C3%A9tricas-con-telegraf-detr%C3%A1s-de-un-firewall-377889b66a1">Recoger métricas con Telegraf detrás de un firewall.</a> was originally published in <a href="https://medium.com/the-cocktail-engineering">The Cocktail Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Visualización de costes en AWS con un stack ELK (Elastic, Logstash, Kibana)]]></title>
            <link>https://medium.com/the-cocktail-engineering/visualizaci%C3%B3n-de-costes-en-aws-con-un-stack-elk-elastic-logstash-kibana-bb984fd6a0c1?source=rss-e1875729aaea------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb984fd6a0c1</guid>
            <category><![CDATA[kibana]]></category>
            <category><![CDATA[elasticsearch]]></category>
            <category><![CDATA[logstash]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[spanish]]></category>
            <dc:creator><![CDATA[Carlos Peñas]]></dc:creator>
            <pubDate>Fri, 10 Jun 2016 07:56:37 GMT</pubDate>
            <atom:updated>2017-08-31T17:05:33.786Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T2qd_p0x34_3FWPU1Hm_-A.png" /></figure><p>Durante el periodo de Free Tier de AWS (e incluso después) todo es fantástico. Los costes de la nube tienen su sentido y más o menos todo sabes de dónde viene y si no lo sabes no pasa nada porque es tu pequeña cuenta laboratorio con dos o tres recursos, tus buckets, tu pequeño servidor, un experimento serverless… Todo está controlado.</p><p>Pero tarde o temprano uno se pone serio, los experimentos tienen que dejar de serlo y salen de la mesa de trabajo, empiezas a tener proyectos de verdad y/o clientes alojados en la nube y un día echas la vista atrás y tienes más de veinte cuentas de AWS con su facturación centralizada. Gastar dinero siempre es triste, así que vamos a ponerle color y de paso puede que nos enteremos en qué nos estamos gastando cada euro de nuesta factura mensual.</p><h4>Activar la generación de informes.</h4><p>Si no estaba activada de antes hay poco que analizar. La <a href="http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/detailed-billing-reports.html#turnonreports">generación de informes</a> es una capacidad que provee Amazon y que hace que periódicamente te entreguen una serie de ficheros CSV con diferentes detalles de la facturación en el bucket S3 que elijamos. Además se entregan también los datos del mes en curso, que se van actualizando día a día por lo que pueden servir para proyectar costes. También es necesario crear un usuario IAM que sólo tenga acceso a ese bucket, o se puede usar un usuario genérico pero lo mejor es separar privilegios. Al usuario de IAM le basta con tener permiso de lectura sobre el bucket designado para la entrega de informes.</p><h4>Empezando a digerir CSVs con Logstash</h4><blockquote><strong>Primeros Pasos</strong></blockquote><p>La ingesta de datos no va a salir a la primera. Solemos empezar haciendo pequeñas pruebas usando sólo Logstash y la salida estándar. La idea es usar el plugin de filtro de CSV. Ésta es la mínima configuración posible, obtiene datos CSV por la entrada estándar y presenta por la salida estándar el resultado:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1500127fb83f39ce98340730891979c1/href">https://medium.com/media/1500127fb83f39ce98340730891979c1/href</a></iframe><p>La manera más cómoda de usar Logstash sin andar con instalaciones es tirar de la imagen oficial de Docker. Para ello creamos un fichero <em>./ls/logstash.conf</em> que usaremos para guardar la configuración mínima y usarlo como volumen de un contenedor con la siguiente orden:</p><pre>docker run -it --rm -v “$PWD”/ls:/cfg logstash logstash:5 -f /cfg/logstash.conf</pre><p>A partir de aquí, copiando lineas de la factura en la consola, podemos ver como serán transformadas antes de empujarlas contra Elasticsearch. <em>(como queríamos probar la alpha 5 del stack ELK este invento no usa la imagen :latest estable)</em></p><blockquote><strong>Campos</strong></blockquote><p>Con esta configuración cada campo presente en un fichero CSV será transformado en una cadena con identificador <em>columnN</em> y<em> </em>así resulta de poca utilidad. Es necesario ponerles nombre usando la opción <a href="https://www.elastic.co/guide/en/logstash/current/plugins-filters-csv.html#plugins-filters-csv-columns"><em>columns</em></a> del plugin. Los nombres de las columnas están en la primera línea del CSV, como en todo buen CSV.</p><p>Todos los datos ingeridos son representados como cadenas. Para transformar los datos existe otra opción <em>convert</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2d392dceae30f66813da63f2ed628541/href">https://medium.com/media/2d392dceae30f66813da63f2ed628541/href</a></iframe><blockquote><strong>Dropeando registros inservibles</strong></blockquote><p>Dentro de la factura que vamos a parsear hay varios tipos de campos. Pero solo nos interesan <em>LinkedLineItem </em>y <em>PayerLineItem</em>. También puede que interese dejar sólo los de tipo linked, ya que por cada pago de cuenta enlazada hay una entrada de pagador de la misma cantidad, por lo que luego hay que retirarlas en las sumas. Modifíquese al gusto.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9598d07835937b831886f3e22fea16c3/href">https://medium.com/media/9598d07835937b831886f3e22fea16c3/href</a></iframe><blockquote><strong>Fechas</strong></blockquote><p>Los campos de fecha no se pueden modificar con el plugin de CSV, para ello es mejor tirar del plugin <em>date</em>. Además dicho plugin sirve para hacer que @<em>timestamp</em>, el campo que indica cuándo se produjo el evento no sea el actual si no el momento del cargo (en nuestro caso <em>BillingPeriodEndDate</em>)</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/58573e7d30a517048840c2451d4dbb76/href">https://medium.com/media/58573e7d30a517048840c2451d4dbb76/href</a></iframe><h4>Ingesta de toda la facturación desde el bucket y volcado a Elastic</h4><p>Con todo lo anterior y algún que otro ajuste adicional que pueda interesar, ya estamos preparados para recoger los CSVs. Primero la salida de nuestro análisis tiene que ser Elasticsearch y no la consola.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e54f91c6aac474070d7bc8ea88c39fdd/href">https://medium.com/media/e54f91c6aac474070d7bc8ea88c39fdd/href</a></iframe><p>El <em>codec dots</em> nos mostrará un punto por cada registro ingerido que viene genial para comprobar que no está parado. Usamos “<em>elasticsearch</em>” de hostname debido a que estamos trabajando con docker.</p><p>En cuanto a la entrada, Logstash puede consumir directamente ficheros descomprimidos desde S3, lo cual nos viene bien para procesar la factura pequeña que tendrá la forma <em>&lt;numero de cuenta&gt;-aws-billing-csv-&lt;fecha&gt;.csv</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3dc6252ee2a92e0d2d3cc0132275625b/href">https://medium.com/media/3dc6252ee2a92e0d2d3cc0132275625b/href</a></iframe><p>Terminada la configuración lanzamos Elasticsearch. El ajuste de <em>sysctl</em> y los parámetros adicionales se deben a <a href="https://github.com/docker-library/elasticsearch/issues/98">un bug entre docker y la alpha de ES</a></p><pre>sudo sysctl -w vm.max_map_count=26214</pre><pre>docker run -d -e ES_JAVA_OPTS=”-Xms1g -Xmx1g” --name elasticsearch elasticsearch:5.0.0-alpha2</pre><p>A continuación lanzamos el contenedor con Logstash, usando la configuración que tenemos en el directorio de trabajo y enlazando al contenedor de Elasticsearch. Queda la configuración final con comentarios en <a href="https://gist.github.com/theist/ef711ee1b71484b2cbeb5596874a83f8">este gist</a></p><pre>docker run -it --rm --link elasticsearch -v “$PWD”:/cfg logstash:5 logstash -f /cfg/logstash.conf</pre><p>Empezará a ingerir datos del bucket y llegado cierto momento se parará (suele tardar unos pocos minutos, según la cantidad de ficheros) Cuando termine podemos cortar la ejecución de Logstash. Si se queda funcionando, cada cierto tiempo (cuando actualizan la factura) la leerá de nuevo, pero al ser una factura completa no es lo ideal.</p><h4>Visualizando la factura con Kibana</h4><p>Una vez cargados los datos podemos arrancar un contenedor con Kibana y realizar las pesquisas necesarias sobre nuestra factura. Aquí ya depende de lo que queramos buscar y no voy a extenderme demasiado. Cada registro del CSV se habrá convertido en un fichero JSON, indexado, convertido a float cuando procedía (para realizar sumas y demás) y podremos realizar búsquedas, filtros y otras investigaciones. Los campos más importantes son</p><ul><li><strong>RecordType</strong>: Si es cargo de cuenta enlazada o no</li><li><strong>TotalCost</strong>: Coste total</li><li><strong>ProductName</strong>: Si se trata de RDS/EC2/S3 …</li><li><strong>ItemDescription</strong>: Concepto (horas de cada tipo de máquina, Kbs transmitidos a determinado precio)</li><li><strong>UsageQuantity</strong>: Cuánto uso hemos hecho del concepto</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0F5vEETEAZQpm-57amyMDw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yEoPnhGpkgGz7Qo4_F_Pqw.png" /></figure><h3>A partir de aquí</h3><p>Se puede realizar el mismo análisis con la factura detallada, que presenta los gastos con granularidad horaria. Pero dicha factura Amazon nos la deja en los buckets en formato ZIP y <a href="https://github.com/logstash-plugins/logstash-input-s3/issues/38">el plugin de S3 de logstash no soporta ficheros ZIP</a> todavía, por lo que se pierde parte de la automatización de este experimento, la solución sería bajarlos en local y procesarlos. Aunque el procedimiento sería el mismo la estructura del CSV entregado es diferente.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb984fd6a0c1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-cocktail-engineering/visualizaci%C3%B3n-de-costes-en-aws-con-un-stack-elk-elastic-logstash-kibana-bb984fd6a0c1">Visualización de costes en AWS con un stack ELK (Elastic, Logstash, Kibana)</a> was originally published in <a href="https://medium.com/the-cocktail-engineering">The Cocktail Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Migrando aplicaciones legacy a Docker]]></title>
            <link>https://medium.com/the-cocktail-engineering/migrando-aplicaciones-legacy-a-docker-97325aa96ac5?source=rss-e1875729aaea------2</link>
            <guid isPermaLink="false">https://medium.com/p/97325aa96ac5</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[sysadmin]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Carlos Peñas]]></dc:creator>
            <pubDate>Tue, 17 May 2016 09:11:28 GMT</pubDate>
            <atom:updated>2016-05-17T09:21:47.353Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/978/1*Rtys6dQpOAXgd7aQyCpMuw.jpeg" /></figure><p>Docker se ha convertido en una figura importante en cualquier stack moderno que se precie. Pero, ¿puede Docker ayudarnos a llevarnos ese servidor que contratamos hace años en una empresa de hosting tradicional, mantuvimos cuando éramos jóvenes y locos, y que nadie es capaz de instalar de cero? ¿Podría incluso permitirnos hacer alguna modificación en el código, aun cuando nadie parece ser capaz de montar un entorno local de desarrollo? Enredemos un poco.</p><h4>Rsync: Vamos a comenzar con lo antiguo</h4><p>Partimos de una aplicación rápida montada en un Debian Lenny(2009) con ruby 1.8.7, rails 2.1.0, memcached 1.2.2, mysql 5.0 y nginx 0.6.32. Hemos tenido que tirar de la paquetería de Debian y no hemos podido preparar un escenario demasiado complejo, porque rubygems en esa versión de ruby ya ni siquiera funciona. Es una aplicación sencillísima, un único modelo y tirando de scaffolding, ni siquiera hemos cambiado rutas.</p><p>Todo el entorno de pruebas está funcionando en un host virtualizado con VirtualBox y, para darle interés y recordando como eran los viejos tiempos, la máquina emulada es Debian 5 de 32 bits.</p><p>Lo primero: obtener los ficheros de la fuente. Con rsync como toda la vida se ha hecho, eliminando partes del sistema operativo (proc, sys…) y directorios temporales o de montaje y usando el usuario root dado que es crítico mantener los permisos:</p><pre>workstation:~# rsync -aAXv --exclude={&quot;/dev/*&quot;,&quot;/proc/*&quot;,&quot;/sys/*&quot;,&quot;/tmp/*&quot;,&quot;/run/*&quot;,&quot;/mnt/*&quot;,&quot;/media/*&quot;,&quot;/lost+found&quot;} root@old_debian:/ docker_image/debian5</pre><h4>Montando la imagen de docker</h4><p>Aun podemos quitar más, es mejor reducir todo lo posible la imagen a crear. Sobran todos los directorios de documentación así como cualquier “extra” que tuviera la máquina.</p><p>Los contenedores de Docker en un principio están pensados para ejecutar un único proceso así que también va a ser necesario hacer algún cambio en el directorio de la app de ruby, básicamente para indicar los nuevos hostnames donde estarán los servicios. Usaré <em>memcache, ruby</em> y <em>database</em> como hostnames para cada contenedor. Tendremos que cambiar (en nuestro caso) <em>config/environments/production.rb</em>, <em>config/database.yml</em> y el virtual host de nginx para que realice la conexion por hostname en vez de usar 127.0.0.1.</p><p>Con esto ya podemos montar una imagen. Se pueden usar Dockerfiles partiendo de la imagen <em>scratch,</em> que es una imagen vacía, pero para hacer la prueba vamos a usar <strong>docker import</strong>, exponiendo los puertos de los servicios. Una vez más, root es necesario para preservar los permisos:</p><pre>user@workstation:~/docker_image/debian5$ sudo tar -cf- . | docker import --change “EXPOSE 80 3000 3306 11211” - thecocktail/old_dog_demo</pre><p>Esto empaquetará todo nuestro directorio y con ello se creará el sistema de ficheros de nuestro contenedor. Realmente una imagen de docker no es mucho más. Dentro de esa imagen residen todos los programas de nuestro stack, así como las librerías de 32 bits que necesitan para funcionar. Como Docker está pensado para ejecutar un único proceso por contenedor, usaremos la misma imagen para ejecutar las distintas partes de nuestro stack. Pese a que la imagen lleva cierta carga extra, es importante entender que aunque existan cuatro contenedores de la misma imagen corriendo en un servidor, el espacio de disco no se multiplica por cuatro, por la manera que tiene Docker de gestionar las capas de disco. Por eso, para esta prueba, no se han separado los servicios en distintos contenedores.</p><h4>Arrancando servicios en contenedores.</h4><p>Lanzaremos un contenedor por servicio, nuestros contenedores no tienen comando por defecto así que hay que habrá que “aprender” a lanzar los servicios en primer plano.</p><p>También es posible haya que reconfigurar algunos de los servicios de la imagen que no estuvieran preparados para trabajar en red (mysql escuchando en local, o con usuarios locales, servicios que usan unix sockets etc…)</p><p>Lanzamos la base de datos</p><pre>docker run -d -p 3306:3306 --name database thecocktail/old_dog_demo /usr/bin/mysqld_safe</pre><p>Si todo ha ido bien y antes del empaquetado se podía conectar de manera externa, debería poderse usar un cliente de Mysql para acceder normalmente. Ahí está el primer contenedor ejecutando una versión antigua de mysql de 32 bits en una moderna estación de trabajo y sin tener que enredar con makefiles y paquetes antiguos de código, ni levantar máquinas virtuales en Linux (en OSX o Windows se sigue dependiendo de la máquina virtual que ejecuta docker, aunque con las últimas versiones de Docker ya se soporta la virtualización nativa para éstos sistemas operativos)</p><p>A por Memcache:</p><pre>docker run -d -p 11211:11211 --name memcached thecocktail/old_dog_demo /usr/bin/memcached -v -m 512 -p 11211 -u nobody</pre><p>Nuestra aplicación Ruby, usando Mongrel como servidor de aplicación, lo tendremos que enlazar para que pueda conectar a los puertos de <em>database</em> y <em>memcached:</em></p><pre>docker run -d -p 3000:3000 --link database --link memcached --name ruby thecocktail/old_dog_demo sh -c &#39;cd /root/demo/ &amp;&amp; RAILS_ENV=production script/server&#39;</pre><p>Ahí tenemos nuestro tercer contenedor con la vieja aplicacion Ruby on Rails. Debería ser posible acceder a <a href="http://localhost:3000/recipes">http://localhost:3000/recipes</a> y verla en el estado que quedó.</p><p>Solo falta Nginx. El principal problema con Nginx es que por defecto arranca y hace un fork, quedándose en background. Cuando esto pasa en un contenedor, el proceso lanzado acaba inmediatamente y el contenedor se para aunque tenga otros procesos corriendo. La vida del contenedor está ligada a la la del proceso que lanza.</p><p>Habrá que realizar un cambio en la configuración añadiendo “daemon off;” para que Nginx se quede en primer plano. Una vez hecho habrá que sacar una imagen nueva o usar “docker commit” para crear una derivada. Esto puede llegar a pasar muchas veces durante un proyecto. Una vez logrado:</p><pre>docker run -d -p 80:80 --link ruby --name nginx thecocktail/old_dog_demo /usr/sbin/nginx</pre><p>Y con esto tenemos todo el stack funcionando en contenedores separados que se enlazan entre ellos. Si todo ha ido bien en <a href="http://localhost/recipes">http://localhost/recipes</a> estará el nginx pasando la conexión a Mongrel que se comunica con Mysql y Memcache para funcionar. Naturalmente esta es la prueba y…</p><h4>Aún queda mucho trabajo</h4><p>Hemos ganado flexibilidad; ahora se puede tomar el stack y cambiar las versiones de los contenedores de servicio (Memcached, Nginx, Mysql) y ver como responde la aplicación sin desplegarla, se pueden pilotar cambios de código o de setup en la aplicación sin necesidad de recurrir a maquinas virtuales y se pueden levantan entornos adicionales con distintas versiones de la aplicacion con relativamente poco esfuerzo. Y por supuesto, podemos apagar ese viejo servidor y llevarnos el stack a otro servidor o proveedor donde dispongamos de servicio de Docker, y redimensionarlo con libertad.</p><p>Si se quiere seguir jugando queda más espacio de mejora:</p><ul><li>Alterar la configuración de los servicios para que entreguen sus logs en stdout</li><li>Componer el stack con docker-compose</li><li>Usar contenedores de datos para almacenar la base de datos o los directorios de imágenes para que la aplicacion no vuelva al pasado cada vez que el stack se reinicia</li><li>Usar service discovery para poder lanzar a voluntad cuantos contenedores de Nginx o Mongrel sean necesarios para responder a picos de tráfico y proveer a la aplicación de alta disponibilidad.</li><li>¿Se necesita lanzar rakes cada cierto tiempo? Habrá que lanzar contenedores nuevos, con la línea de comando necesaria, programando su ejecución con algún sistema de planificación de tareas</li></ul><p>La imagen tal cual la he exportado, después de un par de modificaciones, está disponible para probar en nuestro <a href="https://hub.docker.com/r/thecocktail/old_dog_demo/">Docker Hub público</a>. Have Fun!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=97325aa96ac5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-cocktail-engineering/migrando-aplicaciones-legacy-a-docker-97325aa96ac5">Migrando aplicaciones legacy a Docker</a> was originally published in <a href="https://medium.com/the-cocktail-engineering">The Cocktail Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>