<?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 anitalmada on Medium]]></title>
        <description><![CDATA[Stories by anitalmada on Medium]]></description>
        <link>https://medium.com/@anitalmada?source=rss-962713f022f7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*VkEC6bRFMRuIzJBOCtAOTA.jpeg</url>
            <title>Stories by anitalmada on Medium</title>
            <link>https://medium.com/@anitalmada?source=rss-962713f022f7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 04:52:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@anitalmada/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[Build y push de imágenes de docker con git tag en GitLab CI]]></title>
            <link>https://anitalmada.medium.com/build-y-push-de-im%C3%A1genes-de-docker-con-git-tag-en-gitlab-ci-9af41240ff53?source=rss-962713f022f7------2</link>
            <guid isPermaLink="false">https://medium.com/p/9af41240ff53</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[gitlab]]></category>
            <category><![CDATA[git-tags]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[gitlab-ci-docker]]></category>
            <dc:creator><![CDATA[anitalmada]]></dc:creator>
            <pubDate>Sat, 13 Nov 2021 00:03:40 GMT</pubDate>
            <atom:updated>2021-11-13T00:03:40.559Z</atom:updated>
            <content:encoded><![CDATA[<p>En este tutorial muestro cómo hacer lo mismo que les comentaba <a href="https://medium.com/@anitalmada/build-y-push-de-im%C3%A1genes-de-docker-usando-la-git-tag-con-jenkins-pipeline-16d42bb21beb">en este otro</a> pero usando solamente GitLab CI. Este ejemplo sirve tanto para usar con los runners gratuitos que provee gitlab.com o con runners propios.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pPHnrA_aGyX_If2KeG5EFg.png" /></figure><p>Tal y como les comentaba <a href="https://medium.com/@anitalmada/build-y-push-de-im%C3%A1genes-de-docker-usando-la-git-tag-con-jenkins-pipeline-16d42bb21beb">en este otro post</a>, la idea es utilizar la Integración Continua y la Entrega Continua con el objetivo de actualizar las versiones del código que tengo organizado en mis imágenes de Docker. Con Integración y Despliegue Continuo lo que logramos es que siempre haya una versión actualizada y disponible de nuestro código, porque en este caso le encargamos a GitLab CI/CD la tarea de generar la imagen, taggearla y subirla a un registry.</p><p>En este caso, voy a usar mi cuenta personal en el <a href="https://hub.docker.com/">registry público de Docker</a> (más conocido como DockerHub) y los runners gratuitos que ofrece GitLab para ejecutar tareas de CI/CD.</p><p>Supongamos que tengo una aplicación (bastante trivial) en NodeJS que consiste básicamente en levantar un servidor web con un saludito poco original. El Dockerfile se los dejo <a href="https://gitlab.com/anitalmada/gitlab-ci-with-tags.git">en este repositorio</a> junto con todo el código que voy a utilizar a continuación.</p><p>Esta aplicación se empaqueta en una imagen que llamaremos “nodeservergl” y lo que yo le voy a pedir a GitLab es que cada vez que se crea una <em>tag</em> se ejecute la pipeline para realizar el <em>build</em>, el <em>tag</em>, el <em>push</em> y el despliegue de la imagen <strong>sólo en el entorno de Desarrollo</strong>. Suponiendo que se pasan todos los tests y las pruebas, el código se mergea luego a una rama que se llama “prod” y en ese caso se dispara otra vez la pipeline pero ejecuta un segudo <em>job</em> que realiza el <em>build</em>, el <em>tag </em>y el <em>push </em>de la imagen considerada “estable” o “para producción.</p><p>Lo primero que tengo que hacer, es agregar un archivo denominado .gitlab-ci.yml en la raíz de mi proyecto, que empezaría más o menos así:</p><pre>image: docker:19.03.12<br>services:<br>#Imagen para evitar problemas de conectividad con el runner gratuito de GitLab<br>  - docker:19.03.12-dind<br>stages:<br>  - build-image<br>  - deploy-image</pre><p>Hasta ahora, lo que definimos fueron los siguientes aspectos:</p><ul><li>la imagen que debe usar el ejecutor de Docker para las tareas de CI, como sabemos que no es una buena práctica usar el <em>tag latest</em> (nos arriesgamos a que en el futuro no funcione nuestra configuración) uso la versión 19.03.12 de la imagen oficial de Docker;</li><li>cuáles servicios y con cuáles imágenes necesitamos que se ejecuten para poder hacer el <em>build</em> de la mía propia, para eso usamos una imagen de tipo “dind” (Docker-In-Docker) ya que se trata de construir una imagen;</li><li>cuáles etapas va a ejecutar esta <em>pipeline</em>, que sería por un lado el <em>build</em> de la imagen (que incluye el <em>tag</em> y el <em>push</em> al <em>registry</em>) y por otro lado el despliegue en diferentes entornos.</li></ul><p>A continuación defino los dos ambientes donde voy a desplegar la imagen:</p><pre>.dev_env: &amp;dev_env<br>  environment: dev<br>  variables:<br>    env_tag: &#39;dev&#39;<br>  only:<br>    - tags<br><br>.prd_env: &amp;prd_env<br>  environment: prd<br>  variables:<br>    env_tag: &#39;prd&#39;<br>  only:<br>    - prod</pre><p>Como verán, a cada ambiente le agrego un “anchor” de YAML (el símbolo “&amp;”) que me va a servir a continuación para duplicar/heredar estas propiedades cuando defina los<em> jobs</em>. Lo que especifico además es que todo lo relacionado a “dev” se ejecutará únicamente cuando se generen <em>tags</em> y todo lo relacionado a “prd” se ejecutará únicamente cuando se pushee código a la rama <em>prod</em>. Además tengo que definir las variables que voy a usar en los comandos para referirme a la imagen a desplegar:</p><pre>variables:  <br>  container_image: &quot;nodeservergl&quot;<br>  my_registry: &quot;anitalmada&quot;</pre><p>Ahora sí, la pipeline con los jobs incluidos quedaría así:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/da58a2d84a6b7d8c10c9aee202e2c9f3/href">https://medium.com/media/da58a2d84a6b7d8c10c9aee202e2c9f3/href</a></iframe><p>Los comandos <em>“before script”</em> realizan la configuración de la conexión SSH entre el runner y el servidor de destino. Por lo tanto, el valor de DOCKER_HOST debe ser reemplazado por los datos de conexión correctos.</p><p>Luego, se ejecutan los mismos comandos que usaríamos en un servidor (o en nuestra computadora personal) para hacer el proceso de <em>build/tag/push</em> manual, con la ventaja de usar parámetros que se repetirán a lo largo de la pipeline: <em>${container_image}</em> para hacer referencia a la imagen que quiero buildear/actualizar y <em>${my_registry}</em> que es el usuario del registry de Docker con el que debo loguearme/subir las imágenes.</p><p>Sin embargo, hay otras variables que no están definidas dentro de la pipeline que serían las variables de entorno. Están nomencladas en mayúsculas y en mi caso particular uso dos tipos:</p><ul><li>las que defino previamente <a href="https://docs.gitlab.com/ee/ci/variables/README.html#create-a-custom-variable-in-the-ui">mediante la GUI de GitLab</a> y que son básicamente los “secretos” que se necesitan para loguearse a servicios externos o para conectarse con hosts remotos (usuarios, contraseñas, llaves SSH, etc.);</li><li>la variable de entorno <em>${CI_COMMIT_TAG} </em>que me permite utilizar la <em>tag</em> del <em>commit</em> y que forma parte del <a href="https://docs.gitlab.com/ee/ci/variables/predefined_variables.html">set de variables predefinidas</a> disponibles en GitLab CI.</li></ul><p>Con estas definiciones puedo ejecutar la pipeline de ejemplo e incluso extenderla a Despliegue Continuo si al entorno de producción le agregamos una etapa de <em>deploy</em> (como hicimos con <em>deploy-dev-image</em>), utilizando la imagen con el tag “prd” y especificando en cuál host debe efectuarse la tarea.</p><p>Para este ejemplo creé una <em>tag</em> 1.1 (directamente desde la interfaz de GitLab pero funciona exactamente igual desde la línea de comandos) y además creé la rama <em>prod</em> para testear el último step de la pipeline. Acá podemos ver los resultados exitosos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/732/1*1K38mdZMQl8SqpzNt0nEBA.png" /><figcaption>Captura del hub en Docker</figcaption></figure><p>Espero que este tutorial te haya servido, o en su defecto te haya inspirado a experimentar con CI/CD. A mí personalmente me encantó el aprendizaje del uso de anclas en YAML y la posibilidad de extender configuraciones para no repetir código, además de experimentar otras formas de definición de pipelines. Recuerden que <strong>las herramientas tienen que ser las adecuadas para nuestro objetivo y no a la inversa</strong>. Nos leemos la próxima.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9af41240ff53" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build y push  de imágenes de Docker usando la git tag con Jenkins pipeline]]></title>
            <link>https://anitalmada.medium.com/build-y-push-de-im%C3%A1genes-de-docker-usando-la-git-tag-con-jenkins-pipeline-16d42bb21beb?source=rss-962713f022f7------2</link>
            <guid isPermaLink="false">https://medium.com/p/16d42bb21beb</guid>
            <category><![CDATA[gitlab]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[jenkins]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[anitalmada]]></dc:creator>
            <pubDate>Wed, 30 Sep 2020 20:51:47 GMT</pubDate>
            <atom:updated>2020-09-30T20:51:47.008Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h3>Build y push de imágenes de Docker usando la git tag con Jenkins pipeline</h3><p><em>Lo que voy a contar acá es la configuración técnica resumida y la forma que yo encontré para simplificar el checkout al repositorio de manera que sólo se ejecute con los push de las git tag (fue lo que me llevó más esfuerzo lograr… y era una gilada 😂).</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VQbW5Tl3RnPjKjOAwxSd7A.png" /><figcaption>Diagrama con el flujo de etapas esperables en la pipeline</figcaption></figure><p>Tal vez se estén preguntando “¿Por qué está usando Jenkins si eso se puede hacer más simple con CircleCI y la integración del propio GitLab?”. Pues bien, básicamente porque el requerimiento origina incluía múltiples notificaciones vía e-mail -obviados en este tutorial- que se deben realizar <strong>entre</strong> <em>stages</em>, configuración ésta que la mayoría de las herramientas de CI/CD ni considera (quizás porque a esta altura de la pregnancia de las metodologías DevOps tantas notificaciones no serían necesarias, pero eso es una discusión que podemos seguir en los comentarios).</p><p>Dicho esto, fue un experimento genial con todo lo que ya sabemos: frustraciones y algarabía en partes iguales.</p><p>Acá les voy a contar sobre ambas ❤</p><p>Primero, Jenkins y sus Jenkinsfile: lo que tiene de complejo lo tiene de poderoso… y de exigente. Si bien el resultado final quedó bastante legible y escueto, me quedé con la impresión de que para realizar algo relativamente lineal y <em>“straightforward”</em> hay que darle muchísimas indicaciones. Pero bueno, es una opinión. Vamos con los hechos.</p><p><strong>Paso 1: Generar el proyecto en Jenkins<br></strong>El tipo de proyecto seleccionado fue el de una pipeline, principalmente porque se trata de un proyecto de CI/Cd que no necesita seguimiento multibranch (todos los tag se generan sólo en la rama master) pero también porque era el tipo de proyecto que se venía utilizando en los productos y se trataba simplemente de <em>“refactorizar”</em> (adivinaron: NOT).</p><p>Hay un montón de tutoriales que muestran cómo configurar una pipeline desde un repositorio con un Jenkinsfile, así que voy a contar solamente que instalé el plugin de GitLab en Jenkins para que me permita conectarse mediante <em>webhooks</em> no-genéricos (Jenkins también tiene esa <em>feature</em>) y después lo único que hice es ir al menú <em>“Administrar Jenkins &gt; Configurar el sistema &gt; Gitlab”</em> y dejé la configuración así:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/973/1*EFvrcd-fYQdJRHjK2r1vbg.png" /><figcaption>Ejemplo de configuración de conexión entre Jenkins y GitLab</figcaption></figure><p>Para generar el API token deben acceder al menú de usuario de su cuenta de GitLab en <em>“Setting &gt; Access tokens”</em> y ahí le ponen un nombre al token, si quieren una fecha de caducidad y en el <em>scope</em> seleccionan <em>“api”</em>. <br>Cuando hagan click en <em>“Create personal access token”</em> les va a mostrar <strong>por única vez</strong> el token. Es mucho muy importante que lo copien en el momento :P</p><p>Una vez que tenemos todo esto listo, es importante chequear que nuestro Jenkins tenga todos los plugins necesarios: <a href="https://plugins.jenkins.io/docker-plugin">Docker</a>, <a href="https://plugins.jenkins.io/docker-java-api">Docker API</a>, <a href="https://plugins.jenkins.io/docker-commons">Docker Commons</a> y <a href="https://plugins.jenkins.io/docker-workflow">Docker Pipeline</a>.</p><p>Por otra parte, Docker tiene que estar instalado en nuestra instancia de Jenkins y el usuario <em>jenkins</em> tiene que tener permisos para ejecutar comandos docker. De lo contrario, la pipeline fallará en la <em>stage</em> de hacer <em>build</em>.</p><p>Por último, dentro de las configuraciones del proyecto nos encargamos de configurar los triggers seleccionando la opción <em>“Build when a change is pushed to GitLab”</em>. Como el <em>webhook</em> que voy a configurar en el paso siguiente solamente se envía con las <em>git tag</em>, aquí le dejo a Jenkins una configuración mínima:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5WT0HXIN4dIbkeluVTjyMQ.png" /><figcaption>Lo mínimo indispensable dentro de la configuración de la pipeline</figcaption></figure><p><strong>Paso 2: El principal requerimiento consistía en “seguir las tags dentro del repositorio”.</strong> <br>Es decir: que cada <em>tag</em> generada en el repositorio del proyecto se convierta en la <em>tag</em> con la que se iba a subir la imagen al registry de Docker. Suena simple, ¿verdad?. Pues bien, Jenkins tiene al menos tres formas diferentes para lograr lo mismo, cada una con sus ventajas y desventajas, pero todas con la exigencia de un estudio moderado a profundo de la herramienta (esto vendría a ser lo que yo considero como <em>mi ganancia</em>). La que elegí, es la que tiene menos que ver con Jenkins y más que ver con el <em>trigger</em> en sí: configuré un <em>webhook</em> en GitLab para que haga un POST a la API de Jenkins sólo cuando se genera una <em>tag</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JJcwp3MrH3__qYt9rmTEtQ.png" /><figcaption>Ejemplo de configuración de Webhook en GitLab</figcaption></figure><p><strong>Lo que aprendí</strong>: la <a href="https://gitlab.com/">versión online de GitLab</a> te permite setear una integración con Jenkins en su menú <em>“Settings &gt; Integrations &gt; Jenkins”</em> pero si usás tu propia instancia de GitLab Community Edition esa integración no está habilitada y hay que usar webhooks sí o sí. Por eso muestro esta configuración. Además, me hizo mucho más simple el primer paso de la pipeline: que el trigger sea solamente una <em>git tag</em>.</p><p><strong>Paso 3: Una vez que testeamos el webhook, podemos empezar a probar el código del Jenkinsfile.</strong><br><em>Disclaimer: no voy a explicar minuciosamente cada parte del código porque este tutorial se va a hacer eterno. Voy a tratar de comentar a grandes rasgos cómo hice para que se cumplan todas las etapas.</em><br>Para empezar, uso <a href="https://www.jenkins.io/doc/book/pipeline/#scripted-pipeline-fundamentals"><em>scripted pipelines</em></a> (que son distintas de las <a href="https://www.jenkins.io/doc/book/pipeline/syntax/#declarative-pipeline"><em>declarative pipelines</em></a>) porque era el estándar que estaban usando para CI/Cd y porque aprendí que permiten mayor minuciosidad incluso en el uso de recursos dentro de los propios ejecutores de Jenkins. Y me fui por la tangente nomás. Volvamos.</p><p>La pipeline define básicamente los mismos pasos que haríamos manualmente: primero <em>build</em> con un Dockerfile de base, luego <em>tag</em> de la imagen y por último <em>push</em> al registry que elijamos.</p><p>Lo primero que hay que hacer antes de las <em>stages</em> es definir variables y funciones que me permitan “extraer” del commit la git tag que necesito usar como docker tag. Para <em>parsear</em> la tag, usé el mismo código del <a href="https://plugins.jenkins.io/git-tag-message/">plugin oficial git-tag-message de Jenkins</a> porque la documentación especifica que <strong>no funciona en proyectos tipo pipeline</strong> sino que hay que usar estas funciones:</p><pre>//proyecto que aloja la imagen en el registry (o user dockerhub)<br>    def proyecto = &quot;anitalmada&quot; <br>//acá el nombre de la imagen a utilizar<br>    def imagen = &quot;hellonode&quot;  </pre><pre>//Funciones para obtener la tag<br>    String gitTagName() {<br>    commit = getCommit()<br>    if (commit) {<br>    desc = sh(script: &quot;git describe --tags ${commit}&quot;, returnStdout: true)?.trim()<br>    if (isTag(desc)) {<br>      return desc<br>       }<br>      }<br>      return null<br>    }<br>    <br>    String getCommit() {<br>    return sh(script: &#39;git rev-parse HEAD&#39;, returnStdout: true)?.trim()<br>    }</pre><pre>    @NonCPS<br>    boolean isTag(String desc) {<br>    match = desc =~ /.+-[0-9]+-g[0-9A-Fa-f]{6,}$/<br>    result = !match<br>    match = null // prevent serialisation<br>    return result<br>        }</pre><p>Ahora sí, vamos a indicarle al nodo que usaremos la variable app (en un <em>stage</em> siguiente) y que debe ejecutar los siguientes <em>stages</em>:</p><ul><li>Clonar el repositorio con un <em>checkout</em> básico, ya que el proyecto estará configurado para que los triggers sean sólo mediante tags.</li></ul><pre>node{<br>    def app<br>   <br>    stage(&#39;Clonar repositorio&#39;) {<br>        //Uso un checkout básico<br>        checkout scm<br>    }<br>//el resto de las stages<br>}</pre><ul><li>Generar la <em>tag</em> en base a las funciones que definimos fuera de las <em>stages</em> al comienzo y que llamamos con <em>gitTagName()</em>:</li></ul><pre>stage(&#39;Generar tag para imagen de docker&#39;){<br>        env.GIT_TAG_NAME = gitTagName()<br>      }</pre><ul><li>Realizar el <em>build</em> de la imagen: aquí utilizamos la variable app para englobar la salida del comando <em>docker build</em> y le pasamos como parámetro las variables que definimos al comienzo y que conformarán nuestra imagen al estilo “anitalmada/hellonode”.</li></ul><pre>stage(&#39;Buildear imagen&#39;) {<br>          app = docker.build(&quot;${proyecto}/${imagen}&quot;)<br>    }</pre><ul><li>Taggear y pushear la imagen a nuestro registry de preferencia, ya que se puede configurar un registry propio o bien usar Docker Hub. En el código, los parámetros de <em>docker.withRegistry</em> son: la URL del registry a utilizar y el ID que le pusimos a las credenciales de tipo<em> Username with Password</em> previamente guardadas en nuestra instancia de Jenkins.</li></ul><pre>stage(&#39;Pushear image&#39;) {<br>      //esta información sobre el registry es custom y se utiliza un ID guardado como variable de Jenkins<br>        docker.withRegistry(&#39;https://registry.hub.docker.com&#39;, &#39;dockerHubID&#39;) {<br>            app.push(&quot;${env.GIT_TAG_NAME}&quot;)<br>      }<br>    }</pre><p>Para generar las credenciales (que en este caso tienen el ID dockerHubID) se debe acceder a <em>“Administrar Jenkins &gt; Credentials &gt; System &gt; Global Credentials”</em> y seleccionar la opción <em>“Add credentials”</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/647/1*Mv1VJhy5LNyDF_KDzj9Tkw.png" /><figcaption>Es un poco tricky el path, presten atención</figcaption></figure><p>En el desplegable elegimos la opción <em>Username with Password</em> y lo que debemos utilizar en cualquier parte de nuestra pipeline donde necesitemos esas credenciales es lo que está en el campo ID:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*Cb1r9gK9otq6ywEAwDVDGg.png" /><figcaption>Campos a completar para generar las credenciales que permitan hacer push al registry</figcaption></figure><ul><li>Avisarle a GitLab que el <em>build</em> de la imagen fue exitoso o fallido y de esta forma gracias a la integración obtendremos el mismo ícono de status que si usáramos la CI/CD nativa de GitLab:</li></ul><pre>stage(&#39;gitlab&#39;) {<br>         echo &#39;Notify GitLab&#39;<br>         updateGitlabCommitStatus name: &#39;build&#39;, state: &#39;pending&#39;<br>         updateGitlabCommitStatus name: &#39;build&#39;, state: &#39;success&#39;<br>    }</pre><p>Si llegaste hasta acá, <strong>¡gracias!</strong> Podés ver el código de esta pipeline con un ejemplo basado en nodeJS <a href="https://gitlab.com/anitalmada/jenkins-tag-images.git">en este repositorio público</a>.</p><p>Te comento que en breve voy a estar dejando la segunda parte de este tutorial donde cuento cómo hago actualización de servicios en Docker Swarm y otro donde cuento esto mismo pero hecho con CircleCI directamente usando CI/CD de GitLab.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=16d42bb21beb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Levantando máquinas virtuales con Vagrant y algunos comandos básicos para trabajar]]></title>
            <link>https://anitalmada.medium.com/levantando-m%C3%A1quinas-virtuales-con-vagrant-y-algunos-comandos-b%C3%A1sicos-para-trabajar-8f516a79844b?source=rss-962713f022f7------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f516a79844b</guid>
            <category><![CDATA[infrastructure]]></category>
            <category><![CDATA[vagrant]]></category>
            <category><![CDATA[shell]]></category>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[virtualization]]></category>
            <dc:creator><![CDATA[anitalmada]]></dc:creator>
            <pubDate>Fri, 25 Jan 2019 15:44:46 GMT</pubDate>
            <atom:updated>2019-01-25T20:05:29.177Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Hace un tiempo me propusieron experimentar con Vagrant para lograr empaquetar un entorno de desarrollo y a continuación les cuento un poco la experiencia que tuve.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s4MJGthrW4OvHneWGRp-2w.png" /><figcaption>Todo un mundo ahí afuera</figcaption></figure><p>Había escuchado hablar de Vagrant cuando buscaba alternativas a <a href="https://www.virtualbox.org/">VirtualBox</a> y <a href="https://virt-manager.org/">Virt-Manager</a>, en el primer caso por el alto consumo en recursos de hardware y en el segundo caso por la curva de apendizaje un poco más elevada y algunos problemas para configurar la red.</p><p>Si bien pude <a href="https://gitlab.com/anitalmada/entorno-oml">empaquetar exitosamente un entorno</a> que finalmente no se utilizó, en este post voy a comentar brevemente cómo levantar máquinas virtuales con Vagrant y algunos comandos básicos que pueden ser útiles, aunque les aconsejo mucho que lean la documentación porque es bastante amigable y tiene ejemplos muy útiles.</p><h3>Primero, instalar</h3><p>En el <a href="https://www.vagrantup.com/downloads.html">sitio oficial de descargas</a> se encuentran los binarios para diferentes sistemas operativos. Todo este tutorial está hecho en Debian, por lo cual todas mis opiniones se basan en mi experiencia dentro de esa distro. En primer lugar, los paquetes de Vagrant se encuentran en los repos pero en una versión bastante desactualizada. Por eso sugiero (<a href="https://www.vagrantup.com/intro/getting-started/install.html#caveats">Vagrant mismo sugiere</a>) que se descarguen los .deb y los instalen manualmente:</p><p># wget <a href="https://releases.hashicorp.com/vagrant/x.x.x/vagrant_x.x.x_x86_64.deb">https://releases.hashicorp.com/vagrant/x.x.x/vagrant_x.x.x_x86_64.deb</a></p><p># dpkg -i vagrant_x.x.x_x86_g4.deb</p><p>Podemos verificar la versión que descargamos:</p><p># vagrant --version<br>Vagrant 2.2.3</p><h4>Segundo, elegir sistema operativo</h4><p>Una de las grandes ventajas de Vagrant en comparación con otras herramientas de virtualización es que posee una especie de repositorio desde donde pullear las imágenes de la distribución que necesitamos emular. A esas “imágenes” le llaman boxes y pueden ver el listado con buscador <a href="https://app.vagrantup.com/boxes/search">ingresando aquí</a>.</p><p>Supongamos que elegimos un CentOS 7. En el mundo previo a conocer Vagrant, una descargaba la iso y luego con la herramienta de virtualización preferida corría una instalación. Esto además de llevar tiempo, consume muchos recursos de hardware. En cambio, con Vagrant hacemos:</p><p>$ vagrant init centos/7</p><p>Y listo.</p><p>No, en serio. Es eso.</p><p>Lo que hace ese comando es colocar un archivo “Vagrantfile” en la ubicación donde ejecutamos el comando, que cuenta con los datos mínimos e indispensables para que al ejecutar el próximo comando Vagrant haga pull de una imagen mínima de CentOS:</p><p>$ vagrant up</p><p>Les debería aparecer algo como lo siguiente, que nos indica que el box se descargó y ya podemos usar nuestra VM:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/870/1*0XnyO8JrSCSgHDXldZlCUw.png" /><figcaption>Este proceso no demora más de un minuto (con buena internet)</figcaption></figure><p>Con esto, ya podemos acceder a nuestra VM con el comando $ vagrant ssh</p><h4>Tercero, tunear la VM</h4><p>Como les comenté en el paso anterior, el Vagrantfile sería el archivo donde podemos customizar nuestra máquina virtual. Solamente voy a detallar los aspectos que yo utilicé, pero pueden ver una revisión más completa de todo lo que nos permite hacer Vagrant viendo <a href="https://www.vagrantup.com/docs/vagrantfile/">esta sección de la documentación</a>.</p><p>En mi caso, necesitaba modificar algunas cuestiones de red, ya que por defecto Vagrant le asigna una IP de nateo a la máquina virtual y yo necesitaba que tenga otra IP privada. Supongamos que además necesitaba tener instalado MySQL.</p><p>El archivo quedaría más o menos así:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/acdd0a238315bb6d28bf31a9dc2c13f2/href">https://medium.com/media/acdd0a238315bb6d28bf31a9dc2c13f2/href</a></iframe><p>Lo que hice primero fue crear un script en ruby que simplemente pasa líneas de comando para provisionar la VM con el repositorio EPEL y los pasos necesarios para instalar MySQL Server.</p><p>Ese script es invocado en la línea 15 y lo que hago en la línea 16 es asignarle a mi VM una IP privada.</p><p>Para que Vagrant realice todo eso en la máquina, usamos el comando reload con el flag de aprovisionamiento:</p><p>$ vagrant reload --provision</p><p><em>Et voilà.</em></p><p>Si ocurre algún error durante la ejecución de los scripts se visualizará en la terminal, podemos revisar si se trata de un error en el Vagrantfile o reintentar ejecutando el mismo comando.</p><p>Este aprovisionamiento se puede hacer por <a href="https://www.vagrantup.com/docs/provisioning/">muchos otros medios</a> además de usar shell scripts, en <a href="https://github.com/anitalmada/tp6-vagrant/tree/master/ansible">uno de mis repos</a> pueden ver cómo hacer algo muy parecido pero con un playbook de Ansible.</p><h4>Algunos comandos de utilidad</h4><p>$ vagrant box update</p><p>Como las boxes se actualizan periódicamente, cada tanto aparecerán avisos de nuevas versiones de la misma distro para lo cual utilizamos este comando y luego procedemos con:</p><p>$ vagrant reload</p><p>Así tenemos siempre nuestras boxes actualizadas. Para eliminar las versiones desactualizadas utilizamos</p><p>$ vagrant box prune</p><p>El listado de las máquinas que tenemos en nuestro equipo se puede ver con:</p><p>$ vagrant global-status</p><p>Y para eliminar máquinas que ya no utilizamos:</p><p>$ vagrant destroy [name/ID]</p><p>… donde [name/ID] es el nombre o el ID de la máquina virtual que obtenemos cuando vemos el status global.</p><p>En próximos posteos les cuento lo que descubrí acerca de los motores de virtualización y demás experimentos con esta herramienta. Pueden pispiar <a href="https://gitlab.com/anitalmada/entorno-oml">por acá también</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f516a79844b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[¡Fork y a graficar!]]></title>
            <link>https://anitalmada.medium.com/fork-y-a-graficar-f9bbd4585229?source=rss-962713f022f7------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9bbd4585229</guid>
            <category><![CDATA[influxdb]]></category>
            <category><![CDATA[devops-training]]></category>
            <category><![CDATA[grafana]]></category>
            <category><![CDATA[alerts]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[anitalmada]]></dc:creator>
            <pubDate>Tue, 22 Jan 2019 20:02:29 GMT</pubDate>
            <atom:updated>2019-01-22T20:21:08.710Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<p><em>Un fin de semana lluvioso me inspiró para experimentar con herramientas de monitoreo. Los resultados: un tablero aceptable en Grafana y una agradable experiencia con docker-compose ❤</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XwjFuo7pvW6Tireae1k5xA.png" /><figcaption>Todo prendido fuego, como nos gusta.</figcaption></figure><p>A medida que una se va inmiscuyendo en el maravilloso mundo del monitoreo descubre que aunque existan múltiples opciones y soluciones técnicas hay una premisa que siempre se verifica: se deben definir los objetivos y luego seleccionarse las herramientas que mejor me ayuden a alcanzar ese objetivo.</p><p>Suena bastante triste*, pero lo único que conocí en “prod” (como reza la jerga) es Nagios y su anticuada/poco amigable interfaz. En algún momento me tocó agregar hosts al listado general del monitoreo que llevamos en mi actual empleo y aunque sobrellevé con éxito la cruzada, viendo en retrospectiva creo que es extenso el procedimiento y entiendo entiendo entonces por qué en parte la tarea me había generado “temor”.</p><p>Al margen de lo robusto y confiable que resulta el núcleo de este producto (algo que ni me atrevo a discutir), está pensado/diseñado para monitoreo de infraestructura estática. Medio que no escala 👎. Igualmente la experiencia de uso de sus interfaces gráficas creo que dejan mucho que desear.</p><p>Insisto en este punto no sólo porque me interese la usabilidad (o sí… ), también porque atenta directamente contra algo fundamental en cualquier organización que es la <strong>gestión del conocimiento, </strong>a menos que sean el club de fans de la documentación bajo normas ISO -lo cual es altamente improbable-. Caso concreto: tenemos instalados un montón de plugines de Nagios que obviamente no sabemos lo que hacen fehacientemente y aparte muchos están customizados con scripts de bash para satisfacer una necesidad particular (sin mencionar los que seguramente ni se están usando). Funcionan bárbaro… pero que alguien más aprenda a adaptarlo, mantenerlo o migrarlo es una tarea que va a llevar mucho más tiempo del que una organización por lo general dispone.</p><p>¿Significa que debemos descartar todo eso y arrancar de cero con algo totalmente nuevo? No necesariamente <em>-se salva de que la apedreen-</em> . Mientras deba mantener una infraestructura estática puedo dejar lo que ya tengo (la regla de elegir la herramienta según el objetivo y <strong>*no*</strong> al revés), sin dejar de buscar opciones para mejorar el monitoreo de lo que se vaya incorporando, o adaptar mejor las herramientas al tipo de infraestructura.</p><p>En esa búsqueda estaba (uf, cuatro párrafos 😅) cuando <a href="https://medium.com/@rdavix">el deivid</a> me comentó que había una forma muy copada -y bastate rápida- de montar un stack simplemente deployando una instancia de docker que contiene InfluxDB y Grafana. Me mandé porque había escuchado hablar de ambas cosas y la vez que quise hacer algo con InfluxDB no me había salido, pero con Docker de por medio me dispuse a darle otra chance.</p><h3>¿Qué hice?</h3><ol><li>Forkear <a href="https://github.com/nicolargo/docker-influxdb-grafana.git">este repo</a>. Es muy útil para arrancar porque ya trae todo dentro de un Docker que corremos con un script que nos provee el mismo repo. <em>Amor del bueno.</em></li><li>Verificar si tengo instalado Docker Compose (y menos mal porque no lo tenía) y poner todo a punto siguiendo las instrucciones de la <a href="https://docs.docker.com/compose/install/">documentación oficial</a>.</li></ol><p>Antes de ejecutar el script del repo, creé dos directorios para la data que vamos a persistir, porque de lo contrario romperemos el corazón de nuestro sistema de monitoreo y se quejará devolviéndonos errores <em>a destra e sinistra</em>. En criollo:</p><p>sudo mkdir -p /srv/docker/influxdb/data</p><p>sudo mkdir -p /srv/docker/grafana/data; chown 472:472 /srv/docker/grafana/data</p><p>3. Ahora sí, corremos el script y cuando vamos a localhost:3000… TARÁAAN</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B-AOABRYMm4W5ufJ8Soljw.png" /><figcaption>Cuando la magia ocurre</figcaption></figure><p>Si leyeron el script para poner a andar todo esto, habrán visto que las credenciales de acceso por defecto son admin/admin. El primero acceso les solicitará que cambien la contraseña y los manda directo al escritorio de trabajo donde deberemos realizar lo siguiente:</p><ul><li>Desde el sector de configuración (ícono de engranaje) seleccionamos “Data Sources” y elegimos el recuadro de “InfluxDB”:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R8xJV8OzE_2P0qYhrhzO6Q.png" /><figcaption>Sí, todas esas Data Sources te permite</figcaption></figure><ul><li>Una vez que seleccionamos el origen de los datos, hacemos las configuraciones de dicha fuente. Es muy importante que en la sección HTTP esté correctamente seteado el puerto de InfluxDB y que el Access sea “Browser”. Si dejamos la opción por default (Server), el “Save&amp;Test” nos fallará. Por último, en InfluxDB Details colocamos “telegraf” como Database y le damos al Save&amp;Test.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SYKsxd7mGrGsjKkGFO18rQ.png" /><figcaption>Perdón, me gusta meterle cositas a las capturas de pantalla</figcaption></figure><ul><li>Ahora sí, podemos armar nuestros tableros (yaaayyy!!). No me voy a explayar mucho porque este post ya es demasiado largo, pero vamos al ícono “+” y seleccionamos “Create dashboard”. Ahí nos va a mostrar todas las opciones de tableros que podemos configurar.</li></ul><p>Dejo para otro posteo la configuración de queries y les invito a <a href="https://github.com/anitalmada/docker-influxdb-grafana">importar mi dashboard</a> (sí, se puede hacer eso) o bien a buscar entre los tableros que <a href="https://grafana.com/dashboards">sube la comunidad</a> para ver alguno que se corresponda con sus necesidades.</p><p>Para ello, vamos a la sección “+” pero seleccionamos “Import”. Allí aparecerán dos campos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*326hrkI_KFJ0anUlX26xTA.png" /></figure><p>Uno nos permite importar directamente con el url o ID que obtenemos cuando buscamos cualquier tablero en la <a href="https://grafana.com/dashboards/">web de Grafana</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GbO_5tE8x6jMzikUE66HzQ.png" /><figcaption>Ejemplo que seguramente vamos a explicar en algún momento con <a href="https://twitter.com/OMniLeads_net">OML</a></figcaption></figure><p>Y el otro nos permite cargar un archivo .json o bien copypastear uno que tengamos a mano, por ejemplo el que les dejé en mi repo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bRWG5-rTGVYW6-Kfe8GfkQ.png" /><figcaption>AHRE</figcaption></figure><p>Y deberían ver algo como lo que les puse al principio, todo prendido fuego, como estamos acostumbradas 🔥 🔥</p><p><em>*no tanto si tenemos en cuenta que no estoy hace tanto tiempo en el mundillo de infraestructura</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9bbd4585229" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>