<?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 Alexis Martínez Chacón on Medium]]></title>
        <description><![CDATA[Stories by Alexis Martínez Chacón on Medium]]></description>
        <link>https://medium.com/@alemarcha?source=rss-c8b74017a968------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*VQpy1aOKKB0sEXBckb-xSQ.jpeg</url>
            <title>Stories by Alexis Martínez Chacón on Medium</title>
            <link>https://medium.com/@alemarcha?source=rss-c8b74017a968------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 00:39:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@alemarcha/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[Comunicación con pasarelas de pago y Domain-Driven Design]]></title>
            <link>https://tech.genial.ly/comunicaci%C3%B3n-con-pasarelas-de-pago-y-domain-driven-design-df54033fedf?source=rss-c8b74017a968------2</link>
            <guid isPermaLink="false">https://medium.com/p/df54033fedf</guid>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[payment-gateway]]></category>
            <dc:creator><![CDATA[Alexis Martínez Chacón]]></dc:creator>
            <pubDate>Tue, 12 Sep 2023 07:39:00 GMT</pubDate>
            <atom:updated>2023-10-10T16:48:46.892Z</atom:updated>
            <content:encoded><![CDATA[<p>Genially ha experimentado una gran evolución en cuanto a cómo los usuarios pueden trabajar con nuestro producto. Las necesidades de los usuarios han cambiado a lo largo del tiempo y, por ello, <strong>nos hemos tenido que adaptar rápidamente a estos nuevos requisitos</strong>. Lejos de ser un problema, <a href="https://tech.genial.ly/lo-que-no-se-lee-en-los-medios-5b0f5f55c349">es otro reto más al que nos enfrentamos</a>. ¡Y es algo que nos encanta!</p><p>Concretamente, hemos sido testigos de cómo el modelo tradicional donde un usuario trabaja en un entorno individual y puntualmente colabora con otros usuarios se quedaba obsoleto. Es por ello por lo que nos pusimos manos a la obra para ir hacia <strong>un nuevo enfoque donde la colaboración y el uso grupal es el eje fundamental</strong>.</p><p>Este cambio de paradigma ha tenido un gran impacto a todos los niveles en Genially ya que a fin de cuentas <strong>nuestro modelo de negocio ha cambiado</strong>. Y si no que nos lo digan al equipo que nos encargamos de toda la gestión de suscripciones. Ahora, en lugar de gestionar suscripciones individuales, tenemos que <strong>gestionar suscripciones para un grupo de usuarios</strong>, lo que conlleva la gestión de lo que denominamos “asientos”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nyrgIChE3VOPiGKmsv5g7A.png" /></figure><p>Dado el aumento de la complejidad esencial del problema, <strong>decidimos refactorizar nuestro backend para </strong><a href="https://tech.genial.ly/gu%C3%ADa-para-la-gesti%C3%B3n-de-deuda-t%C3%A9cnica-fd1da78940c9"><strong>tratar de reducir la complejidad accidental de nuestro código</strong></a>. Gracias a toda la experiencia adquirida durante estos años en cuanto a la gestión de suscripciones y en cuanto al diseño orientado al dominio, pudimos hacer una serie de mejoras que nos han simplificado la vida.</p><p>Y una de estas mejoras es justamente lo que os venimos a contar en este post. Si en tu día a día <strong>tienes que lidiar con los problemas derivados de la integración con pasarelas de pago</strong>, creemos que esto os puede interesar. Stay tuned!</p><h3><strong>Gestionando la complejidad con Domain-Driven Design</strong></h3><p>Hace ya tiempo que en Genially apostamos por utilizar<strong> </strong><a href="https://tech.genial.ly/del-modelado-an%C3%A9mico-al-modelado-enriquecido-del-dominio-4280dd87e470"><strong>un diseño orientado al dominio y arquitecturas limpias</strong></a> como la mejor manera de reducir la complejidad accidental en nuestro código. Creemos que es la mejor manera de desarrollar software de forma efectiva y que esté alineado con los requisitos de nuestro negocio.</p><p><strong>El uso de los principios de Domain-Driven Design (DDD) nos ayuda a la gestión de la lógica de negocio</strong> al tener un lenguaje ubicuo<strong> </strong>que facilita la comunicación en el equipo (donde hay gente de producto y tecnología, negocio…). Además, <strong>dota nuestro código de la semántica de dominio</strong> favoreciendo una rápida detección de los problemas en la lógica de negocio y de la capacidad de adaptación al cambio de los mismos. En definitiva, lo que desde nuestro punto de vista entendemos por escribir un código de mayor calidad.</p><p>Por otro lado, la implementación de arquitecturas limpias nos permite el <strong>desacoplamiento de la lógica de negocio y la infraestructura</strong>. Este desacoplamiento nos da la independencia necesaria para ser más <strong>tolerantes al cambio</strong> y nos proporciona <strong>una mayor robustez</strong> al separar las responsabilidades en capas bien definidas y diferenciadas. Por ejemplo, podemos realizar tests de manera muy sencilla que nos facilitan el mantenimiento del código.</p><p>Sin embargo, el <strong>realizar un buen diseño del dominio junto con una arquitectura limpia no es algo sencillo</strong>. Es algo que requiere tiempo, mucha práctica y <a href="https://tech.genial.ly/una-visi%C3%B3n-pragm%C3%A1tica-sobre-el-desarrollo-de-software-181ac9f48670">una mentalidad de aprendizaje continuo</a>. Y es que, más importante que hacer un modelo del dominio “perfecto” a la primera, es la capacidad de iterar y mejorar ese modelo en base a la experiencia.</p><p>En nuestro caso, uno de los problemas al que nos enfrentamos a la hora de modelar la gestión de las suscripciones de Genially fue <strong>cómo integrar las pasarelas de pago (que son servicios externos) en nuestro dominio</strong>, evitando tener separada la lógica de negocio dispersa en varios puntos de nuestro código y sin acoplarnos a implementaciones concretas.</p><p>Este problema nos hizo tener que pensar en diferentes alternativas que nos ayudaran a poder gestionar de la forma más sencilla y rápida toda la comunicación con las pasarelas de pago en los numerosos casos de uso. Por supuesto, no dimos con la solución “ideal” a la primera, sino que <strong>hemos ido aprendiendo e iterando a lo largo del tiempo</strong> hasta tener una solución con la que el equipo se siente cómodo.</p><h3><strong>Integración con pasarelas de pagos</strong></h3><p><strong>Una pasarela de pago es un servicio externo que actúa como intermediario entre comprador y vendedor</strong>, de forma que el vendedor puede recibir pagos sin acceder a los datos bancarios del comprador. Esto permite <strong>implementar un sistema de procesamiento de pagos</strong> de forma sencilla y que garantiza la seguridad en cada transacción. Las plataformas de pago que usamos en Genially a día de hoy son <a href="https://stripe.com/">Stripe</a> y <a href="https://www.braintreepayments.com/">Braintree</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CX7QTsLlffVkxqF-PonkYg.png" /><figcaption>Imagen obtenida de <a href="https://www.google.com/url?q=https://iq.opengenus.org/payment-gateway-system-design/&amp;sa=D&amp;source=docs&amp;ust=1694012240280816&amp;usg=AOvVaw3AygSs5sI4OxRUv53XqkMw">https://iq.opengenus.org/payment-gateway-system-design/</a></figcaption></figure><p>Integrar nuestro sistema con las pasarelas de pagos, siguiendo un modelado orientado al dominio, es <strong>uno de los mayores desafíos a los que nos hemos enfrentado</strong> en el desarrollo de toda la parte de gestión de suscripciones. Y aún más siendo un servicio crítico dentro de la empresa. Pero, ¿a qué nos referimos exactamente cuando decimos que esta integración es un desafío?</p><p>Hay que tener en cuenta que cualquier acción que se quiera realizar sobre un pago, una suscripción, un método de pago o una factura, <strong>debe realizarse a través de la pasarela de pago correspondiente</strong> (que, recordemos, es un servicio externo). Y todo lo que ocurra allí es tan importante como nuestra lógica de negocio ya que<strong> la pasarela de pagos es la que realiza la transacción y determina si algo ocurre o no finalmente</strong>.</p><p>Por lo tanto, nuestro principal objetivo era <strong>encontrar una solución que nos permitiera gestionar toda la comunicación con la pasarela de pago lo más cerca posible de nuestro dominio</strong>. Queríamos lograr así un dominio lo menos anémico y lo más cohesionado posible.</p><p>Sin embargo, que la pasarela de pago tenga tanta importancia en los casos de uso nos dificultaba este objetivo. Pensad que en prácticamente<strong> cada caso de uso se debe realizar una acción intermedia entre la validación de nuestras invariantes y la mutación del agregado </strong>que involucra la comunicación con la pasarela de pago. Esto es algo que si no diseñamos bien, nos puede llevar a tener un código donde el dominio es anémico e incluso a hacer un código difícil de mantener.</p><p>Para abordar este problema, nos <strong>planteamos varias alternativas que nos permitieran modelar de la mejor manera posible todo esto</strong>. Concretamente, valoramos la opción de delegar la comunicación con la pasarela de pago al repositorio. También valoramos la opción de que uno, o varios, servicios de dominio orquestaran esta lógica. Vamos a ver cada alternativa con un poco más de detalle.</p><h3><strong>Alternativas para modelar la comunicación con pasarelas de pagos</strong></h3><h4><strong>Delegando en el repositorio</strong></h4><p>Una de las opciones que se planteó consistía en <strong>delegar tanto la persistencia del agregado como la comunicación con la pasarela de pago en la capa de infraestructura</strong>. El razonamiento es que, si la pasarela de pago es la que finalmente decide si algo ocurre o no, podría encajar bien con delegar esta responsabilidad en el repositorio y decidir ahí si realmente el agregado se persiste o no.</p><p>Si consideramos que la conexión con la pasarela de pago no es parte del modelo de dominio, esta opción podría simplificar la capa de dominio y casos de uso. Sin embargo, <strong>esta solución oculta la complejidad de la integración con el servicio externo </strong>y nos obliga a asegurarnos de que todo funcione correctamente a nivel de infraestructura.</p><p>Simplificar la capa de aplicación y de dominio <strong>nos puede llevar a una discrepancia entre lo modelado a nivel de casos de uso y dominio, y lo que realmente ocurre en la integración con la pasarela de pago</strong>. Además hay que tener en cuenta que el concepto de “pasarela de pago” queda fuera del lenguaje ubicuo del dominio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hNAPTrOZXnqqxg41" /></figure><h4><strong>Orquestando con servicios de dominio</strong></h4><p>En esta otra solución partimos de la base de que <strong>tanto la lógica asociada a la comunicación con la pasarela de pago y la modificación de agregado pertenecen al modelado del dominio</strong>, al contrario que la opción anterior. Para ello, se encapsula tanto la comunicación con la pasarela de pago, como la lógica de negocio relacionada, en uno o varios servicios de dominio.</p><p>Con esta solución, si bien no tenemos toda la lógica de negocio a nivel de agregado, al menos la tenemos lo más cerca posible. Sin embargo, al no estar empujando la lógica hasta lo más profundo del dominio (el agregado), <strong>estamos creando una especie de capa intermedia </strong>que nos complicaba un poco la gestión de toda la lógica. Además nuestros agregados no son todo lo ricos que podrían ser, al contrario que los casos de uso que tienen que tener algo más de lógica.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ImUrIUQzPqgEFKh4" /></figure><h3><strong>Modelando con servicios de dominio, la opción elegida</strong></h3><p>La opción de utilizar <strong>servicios de dominio para manejar la lógica de negocio y la conexión con las pasarelas de pago </strong>es la que más nos convenció. Y es la que finalmente implementamos en nuestro proyecto.</p><p>Siempre hemos tenido como objetivo tener un modelo rico de dominio. Y <strong>con esta solución conseguimos tener una representación más fiel de las reglas de negocio </strong>en el dominio, facilitando la compresión, legibilidad y mantenimiento del código.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f144655088c6ef04fbf15dce43e7a278/href">https://medium.com/media/f144655088c6ef04fbf15dce43e7a278/href</a></iframe><p>Por si fuera poco, también conseguimos que <strong>toda la orquestación y lógica relacionada con la transacción que estamos implementando quede encapsulada en un único punto</strong>: el servicio de dominio. Esto nos simplifica la gestión y el rastreo de las operaciones relacionadas con la pasarela de pagos, en lugar de tenerlo a nivel de infraestructura.</p><p>Teniendo en cuenta todo lo que hemos mencionado ya tenemos argumentos de sobra para justificar esta solución, pero aún hay más. También podemos hacer<strong> pruebas unitarias a nivel de caso de uso incluyendo la interacción con la pasarela de pagos</strong>, lo que nos da una mayor robustez, agilidad y confianza a la hora de testear esta parte.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3a3ab3cd4616aaa8e240f47b11b6bac1/href">https://medium.com/media/3a3ab3cd4616aaa8e240f47b11b6bac1/href</a></iframe><p>Sin embargo, durante la implementación de esta solución <strong>nos dimos cuenta de algunos inconvenientes</strong> que teníamos que considerar. Como casi siempre ocurre, nunca una solución es un camino de rosas.</p><h3><strong>Problema: Lógica de dominio en servicios de dominio gestionado por la capa de aplicación</strong></h3><p>Esta solución <strong>nos funcionó bien ya que pudimos implementar toda la gestión de suscripciones y pagos de Genially</strong>. Pero en nuestro afán de mejora continua, había algo que no nos terminaba de convencer en relación a cómo lo habíamos implementado.</p><p>Con la implementación que hicimos inicialmente, <strong>la lógica de verificación de la lógica de dominio y la mutación del agregado se separaban debido a la acción intermedia requerida en la comunicación con la pasarela de pagos</strong>. Esto generaba una “distorsión” en el agregado, ya que no reflejaba las reglas de negocio de manera coherente. Además, esto provocaba que quedara todo un poco inconexo.</p><p>Seguramente os estaréis preguntando qué significa eso de “distorsión e inconexión en el agregado”. Al tener una “pseudocapa” adicional para la integración con la pasarela de pago, <strong>existe la posibilidad de un mal uso tanto de los agregados como de los servicios de dominio</strong>. Es decir, la realidad es que para mutar el agregado siempre hay que usar previamente el servicio de dominio para asegurarnos de que la transacción ocurre en la pasarela de pago. Pero no hay nada que nos impida mutar el agregado sin invocar al servicio de dominio, y viceversa, porque es el servicio de aplicación el que lo orquesta.</p><p>Para ilustrar estos problemas, presentamos un ejemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9bcf533442896b7b61700d897ad13ce3/href">https://medium.com/media/9bcf533442896b7b61700d897ad13ce3/href</a></iframe><p>En este ejemplo tenemos una clase que hace referencia a<strong> un servicio de dominio encargado de gestionar las acciones que interactúan con la pasarela de pago</strong> y, al mismo tiempo, validar y mutar el agregado. Tomemos como ejemplo el caso de agregar asientos a una suscripción:</p><ol><li><strong>Verificación de las invariantes </strong>a nivel de negocio en el agregado de suscripción. Esto nos indica si cumplimos las condiciones para agregar asientos a la suscripción.</li><li><strong>Petición a la pasarela de pago</strong> correspondiente para realizar los cambios.</li><li><strong>Mutamos el agregado</strong> llamando a un método que actualiza los asientos.</li></ol><p>Este ejemplo refleja las problemáticas mencionadas anteriormente, ya que <strong>la lógica se encuentra dispersa entre el agregado y el servicio de dominio</strong>, lo cual dificulta la coherencia y el encapsulamiento de la lógica de negocio. Además de que nada impide que el agregado pueda ser mutado fuera de este servicio de dominio, lo que<strong> nos llevaría a un estado inconsistente de la suscripción </strong>donde la pasarela de pago y nuestra base de datos tienen un estado distinto.</p><p>Debido a estos problemas, nos vimos en la necesidad de reconsiderar la solución y buscar alternativas que nos permitieran<strong> abordar la integración con las pasarelas de pago de manera más coherente</strong> y alineada con los principios de DDD.</p><h3><strong>Solución: Agregado coordina las llamadas al servicio de dominio</strong></h3><p>Al final, queríamos conseguir que el agregado se encargara de la lógica de comunicación con la pasarela de pago y de la mutación del propio estado del agregado. Así que en lugar de usar un servicio de dominio como “pseudocapa” intermedia para coordinar esa gestión, <strong>inyectamos la abstracción de dominio de la pasarela de pago directamente en el método del agregado correspondiente</strong>. Esto nos permite poder encapsular toda la lógica de negocio en el agregado y deshacernos de esa “pseudocapa”.</p><p>A priori, esta solución nos puede parecer extraña por el hecho de inyectar un servicio de dominio en un método del agregado. Pero lo cierto es que, si lo pensamos bien, esta dependencia indica que, para llevar a cabo esa acción, se necesita forzosamente el servicio de dominio encargado de la comunicación con la pasarela de pago. Por lo tanto, conseguimos las dos cosas que buscábamos:<strong> 1) que el agregado contemple toda la lógica necesaria para realizar la acción de dominio, y 2) que no se pueda mutar el agregado sin el servicio de dominio, evitando las inconsistencias comentadas con anterioridad</strong>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2d9f4f252447ece547923121b6ad50ee/href">https://medium.com/media/2d9f4f252447ece547923121b6ad50ee/href</a></iframe><p>Aquí tenemos un ejemplo de cómo quedaría un caso de uso tras el refactor. Realmente <strong>a nivel de código no se nota demasiado la diferencia</strong>, más que el hecho de que en lugar de invocar a un servicio de dominio para manejar la lógica que conlleva esa acción, invocamos directamente al método del agregado <em>subscription.addSeats</em> que mostramos en el siguiente fragmento de código:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6d833ad2040a82e0a11eab9601dcea78/href">https://medium.com/media/6d833ad2040a82e0a11eab9601dcea78/href</a></iframe><p>Tomando como ejemplo el método <em>addSeats</em> del agregado <em>Subscription</em>, podemos observar <strong>cómo ahora esta lógica está integrada y encapsulada </strong>en un solo lugar, evitando separaciones y mejorando la cohesión.</p><p>En definitiva, las ventajas que obtuvimos con esta solución fueron las siguientes:</p><ol><li><strong>Encapsulación completa</strong>: Toda la lógica de dominio y la comunicación con la pasarela de pago se encuentra dentro del método del agregado. No hay necesidad de separar la validación de los datos y la llamada a la pasarela de pago en métodos distintos como en la solución anterior con los servicios de dominio.</li><li><strong>Evitar confusiones</strong>: Al tener la lógica encapsulada en el método del agregado, se evitan confusiones o errores al invocar directamente el método del agregado en lugar de llamar al servicio de dominio correspondiente. Esto garantiza que se sigan los flujos adecuados y se realicen todas las acciones necesarias.</li><li><strong>Eliminación de métodos de validación públicos</strong>: Al no requerir validaciones externas al agregado antes de llamar a la pasarela de pago, no es necesario exponer públicamente los métodos de validación del agregado. Esto mejora la encapsulación y evita que se realicen validaciones incorrectas o inadecuadas fuera del agregado.</li><li><strong>Trazabilidad y legibilidad del código</strong>: Al tener toda la lógica en un solo lugar, el código se vuelve más legible y fácil de seguir. Es más sencillo comprender qué acciones se realizan y en qué orden, lo que facilita el mantenimiento y la comprensión del sistema.</li><li><strong>Simplificación de la experiencia de desarrollo</strong>: Al seguir los principios de DDD y arquitecturas limpias se simplifica en gran medida la experiencia de desarrollo. No es necesario tener en cuenta reglas internas complejas, ya que se sigue un patrón claro y se trabajan dentro de los límites del agregado.</li></ol><h3><strong>Conclusiones</strong></h3><p>Como habréis podido apreciar, el proceso hasta llegar a una solución que nos convenciera ha sido largo, complejo y muy debatido dentro del equipo de Genially. Y hay que tener en cuenta que se ha ido pensando y decidiendo <strong>sobre la marcha, con un proyecto ya en producción, funcionando y con la necesidad de ir refactorizando poco a poco</strong>.</p><p>En resumen, utilizar DDD en la gestión de suscripciones y pagos de Genially nos ha proporcionado una serie de beneficios, como <strong>una mejor gestión de la lógica de negocio, separación de la lógica de negocio y la infraestructura, encapsulación de la lógica en un solo punto y facilidad de comunicación con otras APIs</strong>. Estos beneficios nos han permitido tener un diseño más robusto y cercano al dominio, mejorando así la calidad y confiabilidad de nuestro sistema.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=df54033fedf" width="1" height="1" alt=""><hr><p><a href="https://tech.genial.ly/comunicaci%C3%B3n-con-pasarelas-de-pago-y-domain-driven-design-df54033fedf">Comunicación con pasarelas de pago y Domain-Driven Design</a> was originally published in <a href="https://tech.genial.ly/">Genially Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Primera aplicación Go usando Docker]]></title>
            <link>https://medium.com/@alemarcha/primera-aplicaci%C3%B3n-go-usando-docker-6b4618833073?source=rss-c8b74017a968------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b4618833073</guid>
            <category><![CDATA[docker-compose]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[golang-tutorial]]></category>
            <dc:creator><![CDATA[Alexis Martínez Chacón]]></dc:creator>
            <pubDate>Wed, 06 May 2020 09:45:50 GMT</pubDate>
            <atom:updated>2023-09-07T11:17:15.849Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LlE7HQi_FeFQrXkC.png" /></figure><h3>Introducción</h3><p>Como todo desarrollador de software hoy en día, sabemos que <strong>docker</strong> comienza a ser una parte prácticamente indispensable en nuestro trabajo diario y cada día gana aún más popularidad. Por otro lado <strong>golang</strong> fue creado por <strong>Google</strong> y se ha hecho popular por su sintaxis, su facilidad a la hora de programar o incluso su eficiente compilación.</p><p>A continuación vamos a intentar explicar un poco, sin entrar en profundidad, las ventajas de porqué nos decidimos por estas dos tecnologías y vamos a dejar un ejemplo de cómo hacer funcionar una aplicación en go ejecutándose en un contenedor de docker.</p><h3>¿Por qué go?</h3><p>Como ya hemos comentado anteriormente, Go es un lenguaje que intenta aunar en un simple lenguaje, tanto la compilación como ejecución eficiente y la facilidad para su programación, pero ademas tiene otras ventajas como.</p><ul><li><strong>Concurrencia</strong>, lo cual no es lo mismo que paralelismo.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/488/1*xKzpWEKAUFep3pdPjuLBeQ.png" /></figure><ul><li><strong>Mantenibilidad</strong> gracias a su sencilla sintaxis.</li><li><strong>Simplicidad</strong>. Por ejemplo no soporta herencia, no tiene constructores, no tiene clases al uso, no hay genéricos aunque es algo que en la comunidad se está demandando, etc.</li><li><strong>Testeo</strong>. Go provee de un package llamado testing para los test automáticos.</li><li>Diseñado y mantenido por <strong>Google</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1010/1*2WLLiddk9yEul_cWcKnzsA.png" /></figure><p>Todo esto hace a Go diferente a otros lenguajes y podrás estar de acuerdo o no, pero la realidad es que tiene todas las ventajas mencionadas. Además tal y como muestra el gráfico, Go supone una situación donde mantiene una tendencia bastante positiva en cuanto a eficiencia y curva de aprendizaje para developers.</p><h3>¿Por qué Docker?</h3><p>El objetivo principal usando docker es poder tener todo el desarrollo en <strong>contenedores</strong>. Esto consiste en tener un entorno para tu aplicación que no dependa de la máquina donde se ejecuta la aplicación.</p><p>Tendremos una seria de ventajas como las siguientes.</p><ul><li><strong>No tener que instalar y configurar</strong> la máquina donde se ejecuta tu aplicación con todas sus dependencias cada vez que cambies máquina, quieras instalarla ó usarla en otra diferente.</li><li>No tendremos además problemas con las <strong>versiones</strong> de estas <strong>dependencias</strong> y <strong>librerías</strong>, ya que especificaremos exactamente las versiones que queremos ejecutar.</li><li>Posibilidad de despliegues automáticos <strong>CI/CD</strong></li><li><strong>Despliegues rápidos</strong></li><li><strong>Multiplataforma</strong>. Podrás ejecutarlo tanto en linux, como MacOS o incluso en windows.</li></ul><p>Todo esto y mucho más hace a docker tan popular y potente.</p><p>Sin extendernos mucho más, vamos a comenzar a con el verdadero objetivo de este post, que consiste en crear un contenedor para ejecutar nuestro proyecto escrito en Go.</p><h3>Código go</h3><p>En primer lugar, si quieres saber cómo <strong>instalar</strong> Go, en la página oficial del lenguaje lo explican bastante bien dependiendo de la plataforma (<a href="https://golang.org/dl/">https://golang.org/dl/</a>). En nuestro caso, este ejemplo lo realizaremos sobre la <strong>versión 1.14.2 de Go</strong>. Lo necesitaremos para inicializar nuestro proyecto y bajar la dependencia de <strong>echo framework</strong></p><p>Para comenzar vamos a crearnos un proyecto Go donde tengamos nuestro archivo principal <strong>main.go</strong>.</p><p>Ejecutamos este comando para inicializar nuestro modulo al cual lo llamamos <strong>dockergo</strong></p><pre>go mod init dockergo</pre><p>Después nos descargamos la dependencia de echo.</p><pre>go get -u github.com/labstack/echo/...</pre><p>Esto añadirá a nuestro proyecto dos archivos <strong>go.mod</strong> y <strong>go.sum</strong> con las dependencias necesarias.</p><p>Posteriormente añadimos el siguiente código al archivo main.go donde tendremos un endpoint de ejemplo creado con el framework echo (<a href="https://echo.labstack.com/">https://echo.labstack.com/</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mSswZ2Zzy6NZQxYl_DfvFw.png" /><figcaption>main.go</figcaption></figure><p>En este código, simplemente vamos a lanzar un <strong>servidor web</strong> que expondrá en el puerto 1323 con endpoint de tipo GET bajo el path<strong> localhost:1223/ping</strong>.</p><p>Con esto ya nos bastaría para el ejemplo. Ahora pasamos a explicar el proceso con docker</p><h3>Docker</h3><h4>Instalar docker y docker compose</h4><p>Es necesario para seguir el ejemplo tener instalado tanto docker como docker-compose. Os dejo los enlaces de la <strong>documentación oficial </strong>donde indican cómo instalarlo dependiendo de vuestra distribución y sistema operativo.</p><p>Para instalar <strong>docker</strong> <a href="https://docs.docker.com/engine/">https://docs.docker.com/engine/</a> y para instalar <strong>docker-compose</strong> <a href="https://docs.docker.com/compose/">https://docs.docker.com/compose/</a>.</p><h4>Construir imagen y contenedor</h4><p>Una vez instalado docker y docker compose, tendremos que crear dentro de la raíz de nuestro proyecto los archivos necesarios de configuración para crear la imagen de docker y lanzar el contenedor donde se ejecutará nuestra aplicación en Go.</p><p>En primer lugar vamos a crear en la raíz del proyecto dos archivos. Uno llamado <strong>docker-compose.yml</strong> y otro<strong> Dockerfile</strong>. Si no sabes qué es docker compose, comentar resumidamente que <em>“es una herramienta que permite simplificar el uso de Docker, generando scripts que facilitan el diseño y la construcción de servicios o de aplicaciones con múltiples componentes”</em>. Si quieres saber más, te remito a la página oficial <a href="https://docs.docker.com/compose/">https://docs.docker.com/compose/</a>. Nosotros en principio usaremos algo básico.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XtwECTm8ojrJP7T1WrMsjw.png" /><figcaption>docker-compose.yml</figcaption></figure><p>Aquí simplemente estamos creando un servicio llamado api, el cual se expone en el puerto 1323. Este servicio será una imagen que se compilará a partir de las instrucciones indicadas en el archivo Dockerfile que crearemos a continuación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eAy5CUxck8aa_PS1V4sfyg.png" /><figcaption>Dockerfile</figcaption></figure><p><strong><em>FROM</em></strong></p><p>En primer lugar creamos nuestra <strong>imagen</strong> partiendo de la imagen oficial de <strong>golang:alpine</strong>. En este caso será la versión latest. Si quieres echar un vistazo, puedes hacerlo en <a href="https://hub.docker.com/_/golang">https://hub.docker.com/_/golang</a>.</p><p><strong><em>ENV</em></strong></p><p>Posteriormente seteamos la <strong>variable</strong> de <strong>entorno</strong> <strong>GOPROXY</strong>=https://proxy.golang.org. De forma resumida <em>GOPROXY es un proxy de Google (CDN) para descargar los paquetes y lo cual nos ayudará a que estas descargas vayan más rápidas sin necesidad de vendoring.</em></p><p><strong><em>WORKDIR y COPY</em></strong></p><p>Establecemos el <strong>directorio</strong> /go/src/api dentro del contenedor como nuestra <strong>carpeta raíz </strong>y <strong>copiamos</strong> todo nuestro directorio en nuestra máquina al WORKDIR establecido dentro del contenedor.</p><p><strong><em>RUN</em></strong></p><p><strong>Ejecutamos</strong> la compilación de nuestra aplicación dentro del contenedor y guardamos el binario en /go/bin/api</p><p>Hasta este punto hemos <strong>generado</strong> una <strong>imagen</strong> que solo contiene en el directorio /go/bin/api nuestra <strong>aplicación compilada lista para ejecutar</strong>. Por lo que ya podriamos terminar nuestro Dockerfile añadiendo el siguiente comando ENTRYPOINT [“go/bin/api”] y compilando la imagen con el siguiente comando.</p><pre>docker-compose build</pre><p>El <strong>tamaño</strong> de esta <strong>imagen</strong> hasta ahora sería como se ve en la captura de pantalla de <strong>448MB</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C6V-wrqLEF9zJBPj4HMBXA.png" /></figure><p>Sin embargo vamos a hacer que el <strong>tamaño</strong> de la <strong>imagen</strong> generada se <strong>disminuya</strong> mucho si añadimos una imagen que solo contenga el binario generado.</p><p><strong><em>FROM</em></strong></p><p>Para ellos partimos de la imagen mínima que tiene linux, con la cual nos bastará para ejecutar nuestro binario. <a href="https://hub.docker.com/_/alpine">https://hub.docker.com/_/alpine</a>.</p><p><strong><em>COPY</em></strong></p><p>Copiamos el binario generado en la imagen anterior desde /go/bin/api a un directorio con el mismo path pero en la imagen generada a partir de la imagen mínima de alpine.</p><p><strong><em>ENTRYPOINT</em></strong></p><p>Una vez que se ejecute la imagen y se levante como un contenedor, el <strong>comando</strong> que se lanzará será el indicado en este ENTRYPOINT, que este caso no es más que la ejecución del binario.</p><p>Ya habríamos terminado nuestros archivos de docker y docker-compose.</p><p>Posteriormente ejecutamos el siguiente comando en la raíz de nuestro proyecto. Con esto conseguimos <strong>construir</strong> la <strong>imagen</strong> de docker que usaremos para <strong>desplegar</strong> nuestro <strong>contenedor</strong> donde ejecutaremos nuestro proyecto.</p><pre>docker-compose build</pre><p>Una vez terminado, ya tendremos nuestra <strong>imagen</strong> generada la cual ahora tiene un <strong>tamaño</strong> muchísimo <strong>menor</strong> que antes. Como vemos en la imagen ahora se queda una imagen de <strong>14.3MB</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lOSrlxcePylwpqO05KvL_A.png" /></figure><p>Posteriormente a partir de esa imagen generada lanzamos el siguiente comando para levantar nuestro contenedor donde se desplegará nuestro código Go</p><pre>docker-compose up</pre><p>En cuanto el contenedor esté ejecutándose, seremos capaces de realizar una llamada a través de nuestro navegador a <a href="http://localhost:1323/ping">http://localhost:1323/ping</a> y nos responderá con un PONG!</p><h3>Conclusión</h3><p>Si queréis el <strong>código completo</strong> del ejemplo podéis verlo en <a href="https://github.com/gosevilla/dockergo_example">https://github.com/gosevilla/dockergo_example.</a></p><p>Cualquier duda que tengáis, la comentáis e intentaremos solucionarla cuanto antes.</p><p>Espero que os haya servido este ejemplo para desplegar vuestra <strong>aplicación Go con docker.</strong></p><h3>Referencias</h3><ol><li><a href="https://medium.com/@leoneperdigao/why-it-is-worth-learning-golang-3a686e4448cf">https://medium.com/@leoneperdigao/why-it-is-worth-learning-golang-3a686e4448cf</a></li><li><a href="https://blog.golang.org/waza-talk">https://blog.golang.org/waza-talk</a></li><li><a href="https://blog.friendsofgo.tech/posts/dockerizando-tu-aplicacion-en-go/">https://blog.friendsofgo.tech/posts/dockerizando-tu-aplicacion-en-go/</a></li><li><a href="https://levelup.gitconnected.com/complete-guide-to-create-docker-container-for-your-golang-application-80f3fb59a15e">https://levelup.gitconnected.com/complete-guide-to-create-docker-container-for-your-golang-application-80f3fb59a15e</a></li><li><a href="https://pro.codely.tv/library/introduccion-a-go-tu-primera-app/89042/path/">https://pro.codely.tv/library/introduccion-a-go-tu-primera-app/89042/path/</a></li><li><a href="https://golang.org/dl/">https://golang.org/dl/</a></li><li><a href="https://echo.labstack.com/">https://echo.labstack.com/</a></li><li><a href="https://docs.docker.com/compose/">https://docs.docker.com/compose/</a></li><li><a href="https://github.com/gosevilla/dockergo_example">https://github.com/gosevilla/dockergo_example</a></li></ol><p><strong>Si te ha resultado interesante/útil puedes apoyarme dando 👏</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b4618833073" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>