<?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 Daniel Estiven Rico Posada on Medium]]></title>
        <description><![CDATA[Stories by Daniel Estiven Rico Posada on Medium]]></description>
        <link>https://medium.com/@danielrico.posada?source=rss-d01e990a1e68------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*zFt74AkN2lc9CZGp3XjFwQ.jpeg</url>
            <title>Stories by Daniel Estiven Rico Posada on Medium</title>
            <link>https://medium.com/@danielrico.posada?source=rss-d01e990a1e68------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 17:20:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@danielrico.posada/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[Exploring the “Why” of Reactive Programming]]></title>
            <link>https://medium.com/@danielrico.posada/exploring-the-why-of-reactive-programming-1eedc7f3c72b?source=rss-d01e990a1e68------2</link>
            <guid isPermaLink="false">https://medium.com/p/1eedc7f3c72b</guid>
            <category><![CDATA[threading]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[reactive-programming]]></category>
            <category><![CDATA[reactor-project]]></category>
            <category><![CDATA[asynchronous-programming]]></category>
            <dc:creator><![CDATA[Daniel Estiven Rico Posada]]></dc:creator>
            <pubDate>Tue, 28 Feb 2023 16:22:54 GMT</pubDate>
            <atom:updated>2023-02-28T16:33:29.155Z</atom:updated>
            <content:encoded><![CDATA[<p>The evolution of users on the internet has been constant over the years and has led to an increase in the demand of applications and systems that can handle large amounts of data and simultaneous requests quickly and smoothly. The <a href="https://www.reactivemanifesto.org/">reactive manifesto</a> has become an important tool in this evolution, as it allows developers to design and build systems that are more responsive, flexible, and resilient to meet modern demands.</p><p>Reactive programming, as a fundamental tool to leverage the reactive manifesto, promotes the use of asynchronous and non-blocking systems, which significantly improves the performance and scalability of applications… but have you ever wondered why reactive programming it‘s more efficient? It’s related to the concurrency model. I will explain better below.</p><h4>One thread per request vs Event Loop</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/867/0*TdvKxfLbPBBSEfPF" /><figcaption><a href="https://www.baeldung.com/spring-webflux-concurrency">https://www.baeldung.com/spring-webflux-concurrency</a></figcaption></figure><p>The “one thread per request” is a traditional concurrency model used in servers like Tomcat, Microsoft IIS and Apache, in which each request is processed on a separate thread. This model is simple and easy to implement, but has some drawbacks when it comes to handling large amounts of simultaneous requests. This approach can consume many system resources, as it needs to create a new thread for each request.</p><p>Additionally, this model may be less efficient in terms of performance, as threads have start-up and shut-down times and can cause blocking and bottlenecks. If many simultaneous requests are received, the system may run out of available thread resources and be unable to process any more requests.</p><p>On the other hand, the “event loop” is a concurrency model used in servers like Netty and other event-based networking tools. In this model, a group of threads work together to process connections and requests in a non-blocking manner. Each thread is responsible for a limited number of connections and uses an event loop to manage I/O operations and network events. When an event occurs, the thread adds it to its event loop and processes it when it is its turn. This allows the system to handle a large number of connections without compromising performance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/864/0*rowXr5KCfUophRJF" /><figcaption><a href="https://www.baeldung.com/spring-webflux-concurrency">https://www.baeldung.com/spring-webflux-concurrency</a></figcaption></figure><p>One benefit of the ‘event loop’ concurrency model is that only a small number of threads are needed to handle a large number of connections. This reduces the amount of system resources needed and improves system performance. Additionally, the ‘event loop’ model is more resistant to bottlenecks and blocking due to the fact that threads have no start-up and shut-down time and only deal with a limited number of connections. The number of threads to be created by this concurrency model are calculated according to the capabilities and cores of the machine’s processor.</p><p><strong>One of the main reasons to use reactive programming</strong> is the use of the event loop as a concurrency model, which clearly demonstrates why reactive programming is more efficient in resource use. The event loop allows the system to more efficiently handle a large number of requests and scale better than one thread per request approaches.</p><blockquote>Now, you may be wondering: why not just increase the number of threads to continue using the <strong>one thread per request</strong> concurrency model and support more users without making any changes to the underlying applications? <br>The answer can be found in the <strong>Universal Scalability Law</strong></blockquote><h3>Universal Scalability Law</h3><p>The universal law of scalability refers to practices and techniques that can be used to ensure that a system is able to scale effectively as it increases in size or complexity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NuPLbiflgNZsURMxwMxcxA.png" /></figure><p>According to the universal scalability law, there is a theoretical scalability that is represented by a linear function. This straight line illustrates the performance of a system in transactions per second (y-axis) as the concurrency increases (x-axis). In this theoretical approach, there is no decline in the system’s response to users as the concurrency increases.</p><p>The universal law of scalability demonstrates that, in practice, a concurrency model based on <strong>one thread per request</strong> can be greatly impacted by <strong>contention and crosstalk</strong>. This means that the system may not be able to maintain consistent performance and may experience degradation in its response to users as the concurrency increases.</p><p><strong>Contention</strong> refers to the situation in which a system’s resources are overwhelmed and unable to handle the demand for work. This can occur when there are too many simultaneous processes or requests trying to access the same resources, such as memory, storage, or CPU. Contention can cause the system’s performance to decrease and can cause delays in responding to user requests.</p><p><strong>Crosstalk</strong> refers to the situation in which different processes or requests interfere with each other and negatively impact the performance of the system. Crosstalk can occur when there are multiple processes or requests that are accessing the same resources at the same time, leading to competition for those resources and potentially causing delays or disruptions in the system.</p><h3>Functional programming and maintainability</h3><p>Reactive programming is an approach that combines functional programming with asynchronous data streams. This offers benefits in terms of scalability but also in maintainability. Functional programming allows for more declarative code writing and avoids side effects during development. It also allows for the avoidance of loops and promotes immutability, which helps prevent concurrency issues.</p><p>For example, if we wanted to implement communication with five REST services in parallel in Java, using a reactive approach would require fewer lines of code than an imperative approach due to libraries that implement the reactive streams specification and their operators that facilitate these types of implementations. In other words, reactive programming allows for more elegant and less code-intensive solutions to problems.</p><h3>Reactive programming in practice</h3><p>There are several options of programming languages that implement the reactive streams specification. For example, in the Spring ecosystem, you can find both the traditional stack and the reactive stack, which currently includes the Reactor project and the Netty server. The latter uses an event loop-based concurrency model instead of the one thread per request approach.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HoQhdVO0-V8GL6Z7" /><figcaption><a href="https://spring.io/reactive">https://spring.io/reactive</a></figcaption></figure><p>Remember not to focus on using technologies just because they are popular. Instead, seek to understand the specific use cases where a particular tool can be useful and the specific benefits it offers. This will help you get the most out of each tool and use it in the most appropriate context.</p><p>Reactive programming can have a steep learning curve. While it offers many benefits, it is important use it in situations where it makes sense and where you can fully utilize its capabilities. This will help you get the most out of this programming technique and avoid unnecessary efforts.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1eedc7f3c72b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[¿Cómo realizar un taller de Domain Driven Design estratégico?]]></title>
            <link>https://medium.com/bancolombia-tech/c%C3%B3mo-realizar-un-taller-de-domain-driven-design-estrat%C3%A9gico-58abe3e8cacf?source=rss-d01e990a1e68------2</link>
            <guid isPermaLink="false">https://medium.com/p/58abe3e8cacf</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[ingenieria-de-software]]></category>
            <category><![CDATA[strategy]]></category>
            <category><![CDATA[planning]]></category>
            <dc:creator><![CDATA[Daniel Estiven Rico Posada]]></dc:creator>
            <pubDate>Mon, 31 May 2021 21:43:22 GMT</pubDate>
            <atom:updated>2021-05-31T21:43:22.432Z</atom:updated>
            <content:encoded><![CDATA[<h3>¿Cómo realizar un taller estratégico de Domain Driven Design?</h3><p>DDD usando Context Mapping</p><p>En una publicación anterior estuvimos hablando acerca del potencial de Domain Driven Design como enfoque para el desarrollo de software y su impacto desde un punto de vista tanto estratégico como táctico. Te recomendamos leerlo para tener un mejor contexto:</p><p><a href="https://medium.com/bancolombia-tech/domain-driven-design-en-bancolombia-de-lo-estrat%C3%A9gico-a-lo-t%C3%A1ctico-6e71a7a81c3a">Domain driven design en Bancolombia— De lo estratégico a lo táctico</a></p><p>En este nuevo artículo explicaremos los diferentes pasos que realizamos para un taller de DDD estratégico en Bancolombia, a través del uso de la herramienta Context Mapping.</p><p>Este es un taller que facilita el entendimiento de un dominio de negocio desde las capacidades que ofrece y de todo el lenguaje que hay alrededor, para posteriormente identificar soluciones tecnológicas para cada uno de los subdominios resultantes del ejercicio.</p><p>Es muy probable que, si estás iniciando en el mundo de DDD, tengas la sensación de entender los conceptos pero no saber muy bien cómo aplicarlos o llevarlos a la práctica — a nosotros también nos pasó — . Por esta razón queremos compartir la forma en que realizamos el taller de Domain Driven Design en su versión estratégica.</p><h3>El taller</h3><h4>Preparación</h4><p>El primer paso consiste en identificar cuáles son las personas con mayor conocimiento del negocio que deben participar en el espacio, además de las personas importantes de tecnología que deben estar presentes.</p><p>El espacio puede ser de manera virtual o presencial, pero recomendamos que no supere las 15 personas. En promedio, se requieren dos espacios de 3 horas, pero puede variar según la complejidad y detalle con que se quiera abordar el ejercicio.</p><p>Solicita a cada una de las personas que van a participar en el espacio que, previamente, construyan una lista de los conceptos de negocio más importantes sobre el dominio que se quiere modelar. Pídeles que te la envíen antes del día del taller.</p><p>¡Recuerda reforzar la idea de que son conceptos de negocio y no conceptos técnicos!</p><h4>Depuración de conceptos</h4><p>Agrupa todos los conceptos enviados por cada uno de los participantes en una sola lista (puede ser en excel o en la herramienta que prefieras) y depúrala borrando los conceptos repetidos — esto ahorrará mucho tiempo y evitará perder la atención de las personas al momento del taller — .</p><p>Es común que algunos no envíen la lista de conceptos, pero es importante cerciorarse de que al menos los principales expertos de dominio sí lo hagan.</p><h4>Contextualización</h4><p>En caso de que sea la primera vez que realices el taller, te vas a encontrar conque muchas personas no tienen idea sobre Domain Driven Design<em>;</em> de hecho, es normal que algunos de ellos estén un poco reacios a realizarlo, debido a que no entienden el valor que genera.</p><p>Por esta razón, es importante iniciar el taller dando un contexto general sobre el objetivo y los resultados esperados, así las personas notarán las ventajas que el taller ofrece y tendrán una mayor disposición para participar.</p><p>Este espacio debe ser muy corto, con unos 15 o 20 minutos debería ser suficiente. Recuerda que la prioridad es mantener la atención de las personas para lograr obtener la mayor cantidad de conocimiento del dominio en cuestión.</p><h4>Definición de subdominios</h4><p>Este es el momento de utilizar la lista previamente construida. Debes iniciar leyendo cada uno de los conceptos, después pregunta a los participantes si consideran que, en ese listado, están todos los conceptos, que ellos como negocio, usan en su día a día. Puede ocurrir que la respuesta sea: no; en ese caso añade todas las ideas que surjan de los participantes.</p><blockquote>Ten presente que la lista de conceptos puede seguirse refinando en cualquier etapa del ejercicio.</blockquote><p>Teniendo el listado de conceptos depurado, el paso siguiente es identificar los subdominios. Un subdominio es un subconjunto o división del dominio general y para identificarlos puedes realizar los siguientes pasos:</p><ol><li>Como equipo, agrupen los conceptos relacionados y den un nombre a esa agrupación. Por ejemplo, si tienes los conceptos: tarjeta, cuotas, pago, franquicias, puedes agruparlos en un subdominio llamado: Tarjetas de crédito.</li><li>Asegúrate de que todos los conceptos queden ubicados en uno de los subdominios. Puedes tener tantos subdominios como sean requeridos, por ejemplo: Tarjetas de crédito, Conciliación, Consumos, Novedades, etc.</li><li>Complementa cada uno de los subdominios con conceptos que el equipo considere que no fueron identificados en la fase inicial.</li><li>Pregunta a los asistentes si consideran que los subdominios que han surgido representan adecuadamente el negocio o si ven necesario crear, combinar o eliminar algún subdominio.</li><li>Intenta que la discusión no sea monopolizada por el equipo de tecnología. Haz preguntas directas a las personas de negocio y asegúrate de que el resultado obtenido realmente represente la forma en que ellos visualizan el negocio.</li></ol><p>En este punto deberías tener un resultado como el siguiente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/937/1*AlfEh3eRkVk5lFwr7YdD6A.png" /></figure><h4>Identificación de relaciones</h4><p>El paso siguiente tiene el objetivo de identificar las relaciones entre los subdominios. Para continuar el ejercicio suele ser más sencillo pasar los subdominios (sin los conceptos) a una herramienta del estilo de draw.io:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/551/1*jkCws-fTUXrNw0MH2Y_CYw.png" /></figure><p>Debes tomar cada uno de los subdominios y trazar una linea hacia o desde los subdominios con los que se relaciona, dependiendo de la dirección. Ten en cuenta que existen diferentes tipos de relaciones como: c<em>ustomer-supplier, anticorruption layer, conformist, partnership, entre otros </em>(revisa el detalle de todos los tipos de relaciones en la documentación oficial de Domain Driven Design).</p><p>Las pregunta claves para encontrar relaciones son las siguientes: ¿Cómo se relaciona este dominio X con este dominio Y?, ¿este dominio X hace uso del dominio Y o el dominio Y hace uso del dominio X?. Dependiendo de la respuesta se traza la línea.</p><p>Adicionalmente, debes ubicar la letra U (u<em>pstream</em>) del lado de la relación que expone la capacidad y la letra D (downstream) del lado del que la consume. Por ejemplo, si se identifica una relación entre un subdominio tarjetas de crédito y un subdominio clientes, en donde clientes consume las capacidades de tarjeta de crédito, se pone la letra U en tarjetas de crédito y la letra D en clientes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*AUJrJqZzZXDLLKQHqDA8Sg.png" /></figure><h4>Clasificación de subdominios</h4><p>Por último, identifica cuáles son los subdominios <em>core</em>, de soporte y genéricos, y márcalos de colores diferentes. Normalmente los subdominios <em>core</em> tienden a quedar en el centro después de identificar todas las relaciones, debido a la dependencia que tienen con otros subdominios.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*kAVgp215Q1XUh7vKRSxdiA.png" /></figure><p>En el anterior diagrama, los subdominios naranjas corresponden a dominios <em>core</em>; los azules a dominios de soporte; y el gris a un subdominio genérico (Para tener mayor detalle sobre qué es cada uno de estos tipos de subdominios revisa el artículo que te recomendamos al inicio de esta publicación).</p><blockquote>Recuerda que con un ejercicio de DDD estratégico se busca entender cómo está estructurado un dominio de negocio a través de las relaciones de sus subdominios para tener una visión a alto nivel.</blockquote><p>Es importante que en este punto les preguntes a los participantes del taller si consideran que el resultado del ejercicio refleja lo que para ellos es el dominio de negocio y realices los cambios que consideres necesarios.</p><p>Como resultado obtendrás un mapa de contextos o subdominios que puedes utilizar para diseñar estrategias de adquisición de software, desarrollo in-house o hasta para planear de manera organizada la definición de API’s para estrategias productor — consumidor.</p><p>Gracias por leer el artículo, si te gustó, compártelo. Además, escribe en los comentarios la experiencia que tuviste al seguir estos pasos, o la forma en que realizas tus talleres de DDD estratégico.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58abe3e8cacf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/c%C3%B3mo-realizar-un-taller-de-domain-driven-design-estrat%C3%A9gico-58abe3e8cacf">¿Cómo realizar un taller de Domain Driven Design estratégico?</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[¿Qué hace una oficina open source en un banco?]]></title>
            <link>https://medium.com/bancolombia-tech/qu%C3%A9-hace-una-oficina-open-source-en-un-banco-3012d4e8ec0e?source=rss-d01e990a1e68------2</link>
            <guid isPermaLink="false">https://medium.com/p/3012d4e8ec0e</guid>
            <category><![CDATA[tools]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[efficiency]]></category>
            <category><![CDATA[innovation]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Daniel Estiven Rico Posada]]></dc:creator>
            <pubDate>Mon, 31 May 2021 18:01:39 GMT</pubDate>
            <atom:updated>2021-05-31T22:43:09.029Z</atom:updated>
            <content:encoded><![CDATA[<p>Creamos la “Oficina Open Source” de Bancolombia</p><p>Es común que como desarrolladores utilicemos software <em>open source</em> para nuestro trabajo diario. Lo que no es tan frecuente es encontrar empresas bancarias que declaren al <em>open source</em> como una estrategia <em>core</em> de la organización; Bancolombia es una de las empresas que le apuesta a esta tecnología.</p><p>En Bancolombia creamos lo que se conoce en comunidades “open” como la oficina del programa de <em>open source</em>, OSPO por sus siglas en inglés <em>(Open Source Program Office)</em>. Un equipo dedicado, tiempo completo, a administrar un programa que fomente el buen uso y liberación de software <em>open source. </em>Para ello, pensamos en cuatro<em> </em>frentes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DkfKJ4BtDPwYjYsj6-RtDg.png" /><figcaption>Estrategia Oficina Open Source — Bancolombia</figcaption></figure><h4>Migración</h4><p>El objetivo es fomentar y acompañar los procesos de migración de tecnologías privativas hacia tecnologías <em>open source</em>. Esta migración permite generar eficiencias económicas en una organización que tradicionalmente ha usado software licenciado. Adicionalmente, la Oficina Open Source promueve la reducción de obsolescencia al migrar componentes que han quedado legados por su acoplamiento a herramientas privativas.</p><p>Para reducir el “riesgo”, que en algunas ocasiones existe al reemplazar un software privativo, contamos con un soporte empresarial de las herramientas <em>open source</em> a las que nos estamos migrando. ¡Es fundamental comprender que pasar a tecnologías <em>open source</em> no significa perder el soporte de las soluciones tecnológicas!</p><p>La migración al <em>open sourc</em>e es el siguiente paso luego del anuncio de convertirnos en un banco 100% <em>cloud</em>.</p><h4>Contribución y estrategia</h4><p>Tener aplicaciones productivas que dependen de ecosistemas <em>open source</em> requiere de esfuerzos que garanticen la salud y permanencia en el tiempo de esas iniciativas. Por esta razón, buscamos vincularnos en la contribución de este tipo de proyectos estratégicos; en los que tradicionalmente hemos tenido un rol más orientado al uso, en vez de la construcción de nuevas características o fortalecimiento de la comunidad.</p><p>Por otro lado, estamos haciendo un esfuerzo en la liberación de proyectos <em>open source</em>. Ya hemos compartido más de seis proyectos que consideramos de gran utilidad para otras organizaciones y desarrolladores. Los puedes encontrar en:<br><a href="https://github.com/bancolombia">https://github.com/bancolombia</a></p><p>Si quieres conocer el proceso, plantillas, listas de chequeo y herramientas que utilizamos para los procesos de liberación, puedes visitar el repositorio central de la Oficina Open Source de Bancolombia:<br><a href="https://github.com/bancolombia/oss-enterprise">https://github.com/bancolombia/oss-enterprise</a></p><h4>OS Compliance y gobierno en el uso</h4><p>El buen uso del licenciamiento <em>open source</em> es uno de los factores principales para evitar inconvenientes legales. En este frente, contamos con verificaciones automáticas que bloquean la descarga de librerías que tienen licencias prohibidas según nuestra <a href="https://github.com/bancolombia/oss-enterprise/blob/master/docs/license-policy.md">política de licencias</a>.</p><p>También buscamos promover nuevas tecnologías <em>open</em> al interior del banco para resolver diferentes retos, así como trabajar en la cultura Open First<em> </em>y en las iniciativas <em>innersource</em>.</p><p>Al trabajar en la cultura Open First<em> </em>al interior de la organización, nuestro objetivo es fomentar el uso del <em>open source</em> con criterio y como primera opción, antes de evaluar alternativas privativas.</p><p>Respecto al innersource, consiste en usar los aprendizajes y buenas prácticas del mundo <em>open source </em>para unir esfuerzos entre organizaciones u equipos al interior para trabajar en retos en común.</p><h4>Comunidades y relacionamiento</h4><p>El frente de comunidades y relacionamiento se enfoca en buscar participación en comunidades externas y fundaciones que nos permitan trabajar en conjunto en retos de industria, traer las mejores prácticas <em>open</em> al banco y dar visibilidad a los proyectos que liberamos; además de apoyar el crecimiento y sostenibilidad de comunidades <em>open source </em>estratégicas para Bancolombia.</p><p>Algunas fundaciones reconocidas son: Linux Foundation, Fintech Open Source Foundation (FINOS), TODO Group y Cloud Native Computing Foundation (CNCF).</p><p>Esperamos que esta publicación te haya dado claridad sobre el objetivo de la Oficina Open Source y las ventajas que puede ofrecer en un banco. Próximamente, publicaremos mayor detalle de las iniciativas que se promueven desde cada uno de los frentes de la estrategia.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3012d4e8ec0e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/qu%C3%A9-hace-una-oficina-open-source-en-un-banco-3012d4e8ec0e">¿Qué hace una oficina open source en un banco?</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Manejo de reintentos en sistemas distribuidos orientados a eventos]]></title>
            <link>https://medium.com/bancolombia-tech/manejo-de-reintentos-en-sistemas-distribuidos-orientados-a-eventos-d40f6b196049?source=rss-d01e990a1e68------2</link>
            <guid isPermaLink="false">https://medium.com/p/d40f6b196049</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[event-driven-architecture]]></category>
            <category><![CDATA[fault-tolerance]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <dc:creator><![CDATA[Daniel Estiven Rico Posada]]></dc:creator>
            <pubDate>Thu, 04 Mar 2021 21:35:18 GMT</pubDate>
            <atom:updated>2021-03-04T21:35:18.041Z</atom:updated>
            <content:encoded><![CDATA[<p>Si existe una constante que podamos resaltar de los sistemas distribuidos y en general del software, es que en algún momento uno de sus componentes va a fallar, por eso, diseñar pensando en como vamos a reaccionar ante esas fallas es la manera más sana de construir software.</p><p>Las fallas pueden ser manejadas bajo diferentes estrategias, que son dependientes del tipo de arquitectura, las tecnologías que se utilicen y la infraestructura con la que se cuente.</p><p>El objetivo de este artículo es explicar desde un enfoque práctico una de las estrategias que se pueden utilizar para que las fallas de un sistema no se conviertan en un dolor de cabeza.</p><p>La estrategia consiste en definir una arquitectura pensada para manejar reintentos en un sistema distribuido que tiene una alta orientación a eventos, diseñado bajo los principios de arquitectura limpia y con enfoque declarativo.</p><p><strong>Tecnologías a utilizar:</strong></p><ul><li>Java 11 / Spring Webflux</li><li>Reactor (Programación reactiva)</li><li>RabbitMQ</li><li>Reactive Commons</li></ul><p><strong>Requisitos</strong>:<br>1. Conocer de manera general los principios de arquitectura limpia que son tratados en este artículo:</p><p><a href="https://medium.com/bancolombia-tech/clean-architecture-aislando-los-detalles-4f9530f35d7a">Clean Architecture — Aislando los detalles</a></p><p>2. Explorar las funcionalidades generales del plugin de arquitectura limpia creado por Bancolombia:</p><p><a href="https://github.com/bancolombia/scaffold-clean-architecture">GitHub - bancolombia/scaffold-clean-architecture: Gradle plugin to create a clean application in Java that already works, It follows our best practices!</a></p><h3>Arquitectura</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dEG3De5SLQMvQwi2vYRKCg.jpeg" /></figure><p>La anterior arquitectura representa un proceso asíncrono de inscripción de una empresa a un convenio. El flujo inicia con una intención de registro por parte de una empresa, esta solicitud es recibida por el entrypoint “reactive-web”, que es un componente que expone servicios REST usando Spring Webflux. Este componente se encarga de dejar la solicitud de inscripción (Comando) en una cola de RabbitMQ, a través del driven adapter “async-event-bus”. Posteriormente responde de manera inmediata (No espera a que el proceso de registro concluya).</p><p>Como existe un nuevo comando de tipo “Subscription” en RabbitMQ, se activa el entry point “event-subscriptions” para procesar la inscripción. El procesamiento de la inscripción consiste en un llamado a un servicio externo http a través del driven adapter “rest-subs-service”.</p><p>Si la inscripción es exitosa, se emite un evento de tipo “event.notification” hacia RabbitMQ. Este evento es procesado por el driven adapter “notification-sender” para enviar el respectivo mensaje de notificación al usuario.</p><p>En caso de que la inscripción falle, porque el servicio esté caído o por otro tipo de error, se reintentará 3 veces. Este reintento consiste en devolver el mensaje a la cola para que sea procesado nuevamente después de que el tiempo de delay configurado haya pasado, situación de la que se encarga reactive-commons. Esta estrategia se conoce como reintentos basados en DLQ.</p><p>Si la inscripción se intenta procesar el número máximo de reintentos configurados, sin éxito, se activará el listener del evento de descarte del mensaje, que en este caso se encarga de guardarlo en Dynamodb a través del driven adapter “dynamodb-fallback”, para que sea monitoreado por las personas encargadas.</p><h3>Implementación</h3><p>El primer paso consiste en crear todos los adaptadores que requerimos haciendo uso del plugin de arquitectura limpia. Para este escenario necesitaremos los siguientes adaptadores:</p><ol><li><strong>reactive-web:</strong> exposición de servicios REST con Spring Webflux.</li><li><strong>async-event-bus: </strong>emisión de comandos hacia rabbitMQ</li><li><strong>event-subscriptions: </strong>subscripción a los comandos y eventos de rabbitMQ.</li><li><strong>rest-subs-service: </strong>se encarga de comunicarse con el servicio externo para la inscripción de empresas.</li><li><strong>notification-sender: </strong>se encarga de notificar al usuario sobre una inscripción exitosa cuando el proceso asíncrono concluya.</li><li><strong>dynamodb-fallback: </strong>guardar los mensajes que fueron descartados por llegar al límite máximo de reintentos.</li></ol><p>Al crear los adaptadores usando el plugin de arquitectura limpia, el proyecto debería verse de la siguiente manera:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-KZc5qSJUQrAoKho7RFZSg.png" /></figure><p>Es importante tener en cuenta que estos adaptadores pueden llegar a ser unidades desplegables distintas si así se requiere según las necesidades propias de cada proyecto.</p><p><strong>Integración con reactive-commons:</strong></p><p>Reactive commons es una iniciativa Open Source utilizada en Bancolombia para facilitar la implementación de aplicaciones orientadas a eventos haciendo uso de diferentes brokers de mensajería como RabbitMQ o SQS.</p><p>Esta librería abstrae muchos de los detalles relacionados a la configuración de las topologías de un broker, la implementación de diferentes patrones de mensajería y estrategias de reintentos para tolerancia a fallas.</p><p>Uno de los principales beneficios es su alta compatibilidad con la especificación de reactive streams y su enfoque declarativo para facilitar la integración con brokers de mensajería.</p><p>Para mayor información de reactive-commons visitar:</p><p><a href="https://github.com/reactive-commons/reactive-commons-java">reactive-commons/reactive-commons-java</a></p><p>Para utilizar la librería reactive-commons se debe agregar la siguiente dependencia en el build.gradle:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/efc51ea3c18ea0187443db4242e55a44/href">https://medium.com/media/efc51ea3c18ea0187443db4242e55a44/href</a></iframe><p>Los adaptadores que requieren de reactive-commons en el escenario planteado son:</p><ul><li>async-event-bus</li><li>event-subscriptions</li></ul><p>En el application.yaml de la aplicación se deben configurar unos parámetros requeridos por la librería reactive-commons relacionados a la autenticación contra el broker y también parámetros de tolerancia a fallas:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e5288daf76bc563bac5fdbfc176b9147/href">https://medium.com/media/e5288daf76bc563bac5fdbfc176b9147/href</a></iframe><p><strong>Parámetros de tolerancia a fallas:</strong></p><ul><li><strong>withDLQRetry</strong>: Permite habilitar la estrategia de manejo de reintentos.</li><li><strong>retryDelay</strong>: Indica el tiempo que debe esperarse entre cada reintento dado en milisegundos.</li><li><strong>maxRetries</strong>: Corresponde a la configuración del máximo número de reintentos que se realizarán.</li></ul><p><strong>Configuración de los listeners:</strong></p><p>En el adaptador “event-subscriptions” deben configurarse los listeners tanto del evento de descarte como del comando de inscripción:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/93ad8c3c3795e07e5c9313b72bce58f6/href">https://medium.com/media/93ad8c3c3795e07e5c9313b72bce58f6/href</a></iframe><p>Caso de uso para procesar la inscripción:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8517d8f578dd9766ddfd47edc88e80c8/href">https://medium.com/media/8517d8f578dd9766ddfd47edc88e80c8/href</a></iframe><p>Subscription Gateway:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/99945b240473c5df14a19247b915bd82/href">https://medium.com/media/99945b240473c5df14a19247b915bd82/href</a></iframe><p>El adaptador concreto para subscription gateway es en este caso la implementación de un llamado http a un servicio externo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c597046a21d5f7f409546608f046dbc0/href">https://medium.com/media/c597046a21d5f7f409546608f046dbc0/href</a></iframe><h4><strong>Procesar mensajes descartados</strong></h4><p>El caso de uso encargado procesar el mensaje descartado por reintentos tiene la siguiente estructura:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dcb403724e9c0d9563ff9fe93d4ea2fc/href">https://medium.com/media/dcb403724e9c0d9563ff9fe93d4ea2fc/href</a></iframe><p>Discard Gateway:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ae8e9b89e1dcabf340e1d76d4a6af659/href">https://medium.com/media/ae8e9b89e1dcabf340e1d76d4a6af659/href</a></iframe><p><strong>Adaptador concreto para DiscardGateway:</strong></p><p>Para este escenario el fallback consiste en llevar el mensaje descartado a dynamodb, por esta razón se requiere un adaptador que asuma esa responsabilidad:</p><p>DynamoDB Fallback:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/77658779c87b34c401ac0e967d34f6f5/href">https://medium.com/media/77658779c87b34c401ac0e967d34f6f5/href</a></iframe><p><strong>Exposición de servicios</strong></p><p>La capa de exposición de servicios corresponde a un entry point desarrollado con Spring Webflux que se encarga de llamar al caso de uso de subscripción y dar respuesta al consumidor final.</p><p>Reactive web entry-point:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c22b284d27b303b281043e3fbe862418/href">https://medium.com/media/c22b284d27b303b281043e3fbe862418/href</a></iframe><p>Caso de uso para la subscripción:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/33b386c451d7c82be5867b3cde9bf43e/href">https://medium.com/media/33b386c451d7c82be5867b3cde9bf43e/href</a></iframe><p>Command Gateway:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4fd4720fbd434288cc88aa5c41841955/href">https://medium.com/media/4fd4720fbd434288cc88aa5c41841955/href</a></iframe><p><strong>Adaptador concreto para la emisión del comando</strong></p><p>Para la emisión del respectivo comando se hace uso de reactive commons en el adaptador async-event-bus de la siguiente manera:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1f272a956aee5442e613dec6669c6e07/href">https://medium.com/media/1f272a956aee5442e613dec6669c6e07/href</a></iframe><p>La implementación completa puede ser encontrada en:</p><p><a href="https://github.com/dericop/retries-dlq-strategy">dericop/retries-dlq-strategy</a></p><p>Esta es una de las diferentes estrategias de manejo de reintentos que existen y que son de gran utilidad para escenarios donde la aplicación debe comunicarse con componentes de software externos de los cuales no se tiene control y principalmente para transacciones que sean compatibles con el asincronismo.</p><p>En los escenarios donde una aplicación no puede soportar transacciones asíncronas o cuando no tienen una orientación a eventos, existen otras estrategias que serán explicadas en publicaciones posteriores.</p><p>¡Muchas gracias por leer esta publicación! Si consideras que fue de utilidad, ¡Compártela!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d40f6b196049" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/manejo-de-reintentos-en-sistemas-distribuidos-orientados-a-eventos-d40f6b196049">Manejo de reintentos en sistemas distribuidos orientados a eventos</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[10 herramientas útiles para un proyecto de desarrollo software]]></title>
            <link>https://medium.com/bancolombia-tech/10-herramientas-%C3%BAtiles-para-un-proyecto-de-desarrollo-software-62db24c1aa72?source=rss-d01e990a1e68------2</link>
            <guid isPermaLink="false">https://medium.com/p/62db24c1aa72</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[banking-technology]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Daniel Estiven Rico Posada]]></dc:creator>
            <pubDate>Mon, 28 Dec 2020 15:01:55 GMT</pubDate>
            <atom:updated>2020-12-30T14:22:33.207Z</atom:updated>
            <content:encoded><![CDATA[<p>El ciclo de desarrollo de software evolucionó de gran manera en los últimos años, siendo transformado principalmente por las propuestas de las comunidades Open Source, que cada día se hacen más importantes para organizaciones de cualquier tamaño.</p><p>Estas propuestas que surgieron de las comunidades Open Source y que hoy son adoptadas por organizaciones como Bancolombia, impactaron de manera muy positiva la calidad del software en distintos sentidos, desde aspectos relacionados a la seguridad y buenas prácticas de desarrollo, hasta iniciativas en pro de garantizar la estabilidad y resiliencia de los sistemas en producción.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8RdwKhUbrJwGQf6L" /><figcaption>Photo by <a href="https://unsplash.com/@timmossholder?utm_source=medium&amp;utm_medium=referral">Tim Mossholder</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>A continuación se encuentra un listado de herramientas utilizadas hoy en Bancolombia, en su mayoría Open Source, para abordar diferentes retos que se dan en las distintas fases del ciclo de desarrollo de software:</p><h4>1. Sonarqube</h4><p>Sonarqube es una gran herramienta para garantizar la escritura de código limpio y seguro de manera automática y continua. Tiene la capacidad de hacer análisis de código estático contribuyendo a crear una base de código mantenible, que evite la duplicidad, la ingesta de bugs y el incremento de la deuda técnica. Además, permite verificar la cobertura de pruebas unitarias.</p><p>Esta es una herramienta gratuita, si se usa para la construcción de proyectos Open Source, en caso contrario, requiere de un pago mensual.</p><p>Las reglas para el análisis estático de código son totalmente personalizables para que sean adaptadas a la guía de estilo de cada organización. Adicionalmente, permite la construcción de reglas propias para verificaciones personalizadas en el código.</p><p>En Bancolombia construimos una serie de reglas personalizadas en sonar que nos permiten verificar por ejemplo: cumplimiento de los principios de arquitectura limpia, configuración adecuada de los YAML de Kubernetes para Readiness Probe y Liveness Probe, validar el no uso de librerías prohibidas, verificar el uso de librerías obligatorias, etc.</p><p>Sonar puede añadirse en los pipelines de integración continua (CI, DevOps) para dar una retroalimentación temprana a los equipos de desarrollo sobre las posibles mejoras en el código que están construyendo día a día.</p><p><strong>Link</strong>: <a href="https://www.sonarqube.org/">https://www.sonarqube.org/</a></p><h4>2. Hygieia</h4><p>Es una iniciativa Open Source creada por Capital One para el monitoreo en tiempo real de los pipelines de CI/CD. Permite generar métricas y dashboards ejecutivos que apoyen la toma de decisiones a través del entendimiento de las fases del proceso DevOps. Además, es una gran herramienta para encontrar demoras o posibles puntos de mejora en el proceso.</p><p>En Bancolombia, cada uno de los proyectos tiene su respectivo dashboard en Hygieia, lo cual permite identificar el nivel de cumplimiento de las iniciativas en los diferentes pilares de DevOps (Continuous integration, Release Management, Continous Delivery, Continuous Testing, Configuration Management) y en las prácticas de Ingeniería de Software.</p><p>Por necesidades específicas de Bancolombia, hoy se trabaja sobre un fork de Hygieia que contiene unas personalizaciones y unas extensiones requeridas por los procesos de la organización. Próximamente, estas extensiones se convertirán en contribución Open Source al core de Hygieia.</p><p>Link: <a href="https://www.capitalone.com/tech/solutions/hygieia/">https://www.capitalone.com/tech/solutions/hygieia/</a></p><h4>3. Azure Pipelines</h4><p>Todos los proyectos de software deben contar con una herramienta para la construcción de pipelines (CI/CD) que fortalezca la automatización y reduzca los reprocesos, materializando los principios de la cultura DevOps.</p><p>Una de las herramientas más reconocidas en el mercado es Azure Pipelines, un servicio muy completo de la suite de Azure DevOps que es soportado actualmente por Microsoft. Este servicio cuenta con integración directa con servicios como Azure Boards, Azure Repos, entre otros, lo que facilita la gestión del ciclo de vida del software.</p><p>Actualmente, Azure Pipelines se encuentra en proceso de evolución hacia Github Actions como resultado de la compra de Github por parte de Microsoft.</p><p>Link: <a href="https://azure.microsoft.com/es-es/services/devops/pipelines/">https://azure.microsoft.com/es-es/services/devops/pipelines/</a></p><h4>4. Artifactory</h4><p>Artifactory es uno de los servicios más reconocidos como repositorio de librerías, binarios e imágenes docker. Es una herramienta fundamental porque al interior de las organizaciones es bastante común requerir de un repositorio que actúe como única fuente de verdad para todos los paquetes e imágenes docker.</p><p>Uno de los casos comunes es la publicación de librerías internas que contienen lógica core de la organización, que al ser sensible, no puede ser enviada a repositorios públicos como npm o maven central. En este caso, se configuran los proyectos para que busquen sus dependencias en artifactory, el cual hará una búsqueda en las librerías privadas de la organización y luego servirá como puente para buscar el resto de librerías en los repositorios de dependencias públicos.</p><p>Hoy Artifactory hace parte de las herramientas utilizadas en los pipelines de DevOps en Bancolombia para la administración de dependencias e imágenes docker.</p><p>Adicionalmente, Artifactory ofrece otras capacidades que puedes encontrar en: <a href="https://jfrog.com/artifactory/">https://jfrog.com/artifactory/</a></p><h4>5. Docker</h4><p>Docker es un proyecto Open Source que automatiza el despliegue de aplicaciones en contenedores, lo cual permite tener una homologación del ambiente en el cual una aplicación va a ser ejecutada. Dando cada vez menos relevancia al sistema operativo o arquitectura del servidor donde se están ejecutando las aplicaciones y dejando a un lado la tradicional frase: “en mi local funciona”.</p><p>Es una de las herramientas que deben ser utilizadas por defecto, si se están construyendo aplicaciones nativas de nube orientadas a cumplir principios de escalabilidad y resiliencia.</p><p>Link: <a href="https://www.docker.com/">https://www.docker.com/</a></p><h4>6. Liquibase</h4><p>Es común encontrar empresas que tengan automatizados sus procesos de despliegue continuo e integración continua para lo relacionado al código de las aplicaciones, pero hay un punto que aún continua generando procesos operativos manuales y corresponde a los cambios en los esquemas de bases de datos.</p><p>Liquibase, es una herramienta que busca evitar estos procesos operativos, ofreciendo implementar pipelines de DevOps para los cambios en las bases de datos.</p><p>Al momento de escritura de este artículo, Bancolombia se encuentra en proceso de implementación de esta herramienta.</p><p>Link: <a href="https://www.liquibase.com/">https://www.liquibase.com/</a></p><h4>7. Prometheus</h4><p>Las aplicaciones empresariales requieren ser monitoreadas 24/7 a través de herramientas que faciliten la detección de errores y que permitan evitar fallas críticas en producción.</p><p>Prometheus es una iniciativa Open Source promovida por la Cloud Native Foundation que ofrece una solución de monitoreo con capacidad de generar métricas, alertamientos y dashboards de visualización sobre el comportamiento de las aplicaciones.</p><p>En Bancolombia se utilizan diferentes herramientas de monitoreo según la necesidad, Prometheus es una de las opciones para algunos casos de uso, pero adicionalmente se cuenta con otras opciones privativas como Dynatrace y New Relic.</p><p>Link: <a href="https://prometheus.io/">https://prometheus.io/</a></p><h4>8. Prisma Cloud</h4><p>La seguridad ha cambiado con la llegada de la nube, abriendo nuevas posibilidades para los atacantes alrededor de la explotación de vulnerabilidades en contenedores docker y en general en las aplicaciones cloud native.</p><p>Prisma Cloud es una herramienta que, además de otras posibilidades, ofrece la capacidad de analizar las vulnerabilidades que puedan presentarse en las imágenes docker base que se estén utilizando para el despliegue de las aplicaciones, reduciendo así las posibilidades de que un atacante vulnere nuestras sistemas.</p><p>Estos análisis pueden ser añadidos como una tarea en los pipelines para evitar que se desplieguen aplicaciones con imágenes base que contengan vulnerabilidades criticas conocidas.</p><p>Link: <a href="https://docs.paloaltonetworks.com/prisma/prisma-cloud.html">https://docs.paloaltonetworks.com/prisma/prisma-cloud.html</a></p><h4>9. XRay</h4><p>Decantarse por utilizar herramientas Open Source es una de las decisiones más positivas que una organización puede tomar; contribuye a generar soluciones de mayor calidad y a menores costos, pero trae consigo retos adicionales como el riesgo asociado por temas de <em>compliance</em>.</p><p>Cuando se utilizan herramientas Open Source es fundamental cerciorarse sobre lo que permite y lo que no permite la licencia que esta herramienta tenga asociada.</p><p>XRay es una herramienta que, además de otras capacidades, permite verificar de manera automática las licencias Open Source que se estén utilizando en todos los repositorios de código de la organización, generando alertamientos o bloqueos si se usan licencias no muy permisivas que puedan traerle problemas legales a la empresa.</p><p>Actualmente en Bancolombia se utiliza para la verificación de licencias Open Source y también para la verificación de vulnerabilidades en librerías.</p><p>Link: <a href="https://jfrog.com/xray/">https://jfrog.com/xray/</a></p><h4>10. Chaos Toolkit</h4><p>Es la herramienta que permite implementar y automatizar los principios de Ingeniería del Caos. Es una manera sencilla de construir experimentos de caos, simulando la caída de servicios críticos en producción para medir, por ejemplo, el nivel de resiliencia de un sistema.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/994/1*MkJ7pRhsECFOmWuQTjwCwA.png" /></figure><p>Al momento de escritura de este artículo Bancolombia se encuentra en proceso de implementación de esta herramienta.</p><p>Link: <a href="https://chaostoolkit.org/">https://chaostoolkit.org/</a></p><h4>Comentarios finales</h4><p>Las herramientas anteriormente nombradas no son un listado exhaustivo de todo lo que se utiliza en el ciclo de vida del desarrollo de Software en Bancolombia, sino algunos ejemplos de las herramientas más útiles y los casos de uso en los que están generando más valor.</p><p>¿Hay alguna herramienta que consideras de gran utilidad y no está en el listado de este artículo? Compártela en los comentarios, puede ser de mucho valor para las personas que lean este artículo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62db24c1aa72" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/10-herramientas-%C3%BAtiles-para-un-proyecto-de-desarrollo-software-62db24c1aa72">10 herramientas útiles para un proyecto de desarrollo software</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Criterios para elegir un stack tecnológico]]></title>
            <link>https://medium.com/bancolombia-tech/criterios-para-elegir-un-stack-tecnol%C3%B3gico-15dfa25764f6?source=rss-d01e990a1e68------2</link>
            <guid isPermaLink="false">https://medium.com/p/15dfa25764f6</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[reactor-project]]></category>
            <category><![CDATA[elixir]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Daniel Estiven Rico Posada]]></dc:creator>
            <pubDate>Mon, 09 Nov 2020 03:30:56 GMT</pubDate>
            <atom:updated>2020-11-09T03:30:56.876Z</atom:updated>
            <content:encoded><![CDATA[<h4>Comparando Elixir, Reactor, Akka y Node.js</h4><p>Es común encontrarse en una situación en la que, elegir el stack para un nuevo proyecto, se convierte en todo un reto. Las búsquedas en <em>google</em> o <em>stack overflow </em>suelen ser los primeros recursos que usamos, escribiendo frases como: ¿es mejor Spring o Node.js?. La realidad y la respuesta a ese tipo de preguntas es: depende.</p><p>Lo más importante ante este tipo de situaciones es tener unos criterios claros para evaluar una u otra opción, dependiendo del escenario y seguir siempre esta regla o recomendación: la mejor herramienta para cada caso de uso. Por tanto, es fundamental no dejarse llevar solo por gustos, ni tampoco hacer una elección de manera apresurada.</p><p>En Bancolombia nos hemos encontrado ante esta situación en varias oportunidades, por eso decidimos hacer una comparación formal, con unos criterios que consideramos útiles, y que puede ser de gran utilidad para tomar este tipo de decisiones.</p><p>En esta ocasión, queremos presentar el resultado de un trabajo comparativo entre herramientas de diferentes ecosistemas: Elixir, Java (Reactor), Node.js, Java (Akka).</p><h3>Criterio 1: Concurrencia vs Throughtput</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qCNCBRhOCtcnAzqZ5OP-dw.png" /></figure><p>La capacidad para soportar usuarios concurrentes es un criterio importante. Si necesitas que una aplicación se mantenga responsiva ante miles o cientos de miles de usuarios concurrentes, debes considerar una plataforma que en un escenario de alta concurrencia, garantice el mejor <em>throughput</em> y con la menor cantidad de infraestructura posible.</p><p>Para este escenario desarrollamos, en cada una de las plataformas, una aplicación que expone servicios REST y permite hacer validaciones sobre una base de datos MongoDB.</p><p>El eje X en la gráfica anterior representa el nivel de concurrencia que lanzamos a estas aplicaciones y que fue variado cada 5 segundos (llegando hasta 2.500 usuarios concurrentes), y el eje Y representa el <em>throughtput</em> (<em>TPS — transactions per second</em>) que puede lograrse bajo una concurrencia específica.</p><p>El top 3 en este criterio es:</p><ol><li>Elixir (hasta 39.000 TPS)</li><li>Akka (hasta 35.000 TPS)</li><li>Reactor (hasta 31.000 TPS)</li></ol><p>Estas tres plataformas — que permiten la construcción de flujos reactivos — arrojaron muy buenos resultados, con algunas pequeñas diferencias en cuanto a su estabilidad.</p><h3>Criterio 2: Latencia</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sjYavqHv8ROmkjzQo_LZ1w.png" /></figure><p>La latencia es un criterio de suma importancia en cualquier sistema, pero cuando hablamos de sistemas distribuidos juega un papel más importante aún, ¿por qué?, esto se debe a que los tiempos que un usuario final va a percibir al realizar alguna transacción, corresponden a la latencia acumulada de los diferentes componentes que hagan parte del sistema.</p><p>En las gráficas anteriores, el eje X tiene que ver con la cantidad de usuarios concurrentes y el eje Y representa la latencia media para cada prueba específica.</p><p>Las pruebas que realizamos sobre latencia nos indican que las aplicaciones Node.js, aunque suelen tener buenos resultados a nivel de <em>throughtput</em>, cuando la concurrencia es demasiado alta y el trabajo que debe realizar no corresponde a I/O, tienen tendencia a arrojar tiempos de respuesta altos.</p><p>Para este segundo criterio buscamos tener la menor latencia posible, para generar mejores experiencias durante la interacción de un usuario con una aplicación.</p><p>El top 3 en cuanto a menor latencia:</p><ol><li>Elixir</li><li>Reactor</li><li>Node Cluster</li></ol><p>Nota: La prueba anterior considera un escenario con carga constante y una afectación incremental (uso abusivo de la capacidad de la CPU por un porcentaje de las peticiones) para, además de la latencia, medir la capacidad de los sistemas para mantenerse responsivos.</p><h3>Criterio 3: Estilo de programación</h3><p>Las decisiones que se tomen alrededor del estilo de programación, tendrán un impacto directo sobre la mantenibilidad y extensibilidad de un sistema. Una adecuada elección en este punto puede evitar asumir complejidades innecesarias en el código, y ayudar a lograr, además, un alto nivel de reúso, eficiencia y expresividad en un caso de uso específico.</p><p>En nuestro caso estamos considerando, para algunos proyectos nuevos, el uso de programación reactiva y funcional con una alta orientación a eventos, debido a que aporta al uso eficiente de los recursos computacionales, y permite tener soluciones más elegantes y mantenibles, que garantizan la responsividad de los sistemas.</p><p>Para conocer con un mayor detalle todos los principios que estamos utilizando en la construcción de sistemas reactivos, puedes leer el siguiente artículo:</p><p><a href="https://medium.com/bancolombia-tech/potenciando-la-arquitectura-de-microservicios-reactivos-88fc84ae0b7d">https://medium.com/bancolombia-tech/potenciando-la-arquitectura-de-microservicios-reactivos-88fc84ae0b7d</a></p><h3>Criterio 4: Popularidad y programación políglota</h3><p>Tal como lo plantea Thoughtworks en su último radar (2020), la popularidad en las tecnologías muchas veces lleva a elegirlas de manera indiscriminada o por las razones incorrectas; de ahí la importancia de elegir la herramienta adecuada para el caso de uso correcto.</p><p>En el caso de Node.js, que tradicionalmente ha sido elegido porque permite construir una aplicación completa en el mismo lenguaje (back y front), es importante considerar que en muchos escenarios no es la mejor opción; a veces es mejor esforzarse en construir un sistema en diferentes lenguajes para sacar el mayor provecho de cada herramienta, en cada parte del sistema.</p><p>Por otro lado, Node.js ha sido utilizado porque fue de los primeros en ofrecer un modelo de programación no bloqueante, muy útil y eficiente para trabajos relacionados a I/O, pero que por su naturaleza single-thread claramente no es una buena opción para cargas pesadas de cómputo.</p><p>Ten en cuenta que los modelos de programación no bloqueantes ya no solo existen en Node.js, sino también en otras opciones que pueden tener API’s más elegantes para el manejo de flujos asíncronos, y que pueden tener un rendimiento bastante bueno para cargas pesadas de computo, como es el caso del proyecto Reactor(Java) y de Elixir (Erlang VM).</p><h3>Criterio 5: Sistemas de alta concurrencia y tolerantes a fallos</h3><p>Actualmente existe bastante diversidad de herramientas para el desarrollo de aplicaciones, pero es importante conocer que algunas de ellas han sido creadas con propósitos muy específicos.</p><p>Cuando hablamos de herramientas para construir sistemas distribuidos de alta concurrencia, tolerantes a fallos y que tengan como principio fundamental la disponibilidad, Elixir (Erlang VM) es una opción muy apropiada.</p><p>Erlang — un lenguaje construido por Joe Amstrong y su equipo en el laboratorio de ciencias de la computación de Ericsson — ha sido utilizado tradicionalmente en el mundo de las telecomunicaciones, pero desde hace un tiempo ha tomado bastante fuerza para la construcción de sistemas distribuidos en otros ámbitos, siendo una de las razones principales la evolución en la sintaxis a través de la propuesta de Elixir. Uno de los casos más conocidos es Whatsapp, quien tiene construido su backend de enrutamiento de mensajes en Erlang y soporta el procesamiento de alrededor de <strong>2.6 billones </strong>de mensajes por hora.</p><h3>Criterio 6: Compatibilidad</h3><p>Considerar los componentes externos con los que un microservicio debe comunicarse, además de los protocolos, <em>drivers</em> y servicios que van a ser usados, es fundamental a la hora de elegir la herramienta con la cual se va a desarrollar.</p><p>Uno de los ejemplos claros es Elixir, un lenguaje con una comunidad open source sólida pero con algunos retos importantes en cuanto algunas librerías externas o <em>drivers. </em>Estos retos están relacionados con que algunas de estas librerías requeridas no existen, no cuentan con buena documentación, tienen versiones muy iniciales o no cuentan con una comunidad open source muy amplia. Por lo tanto, elegir este stack, en algunos casos, puede no ser la mejor opción.</p><h3>Conclusión</h3><p>La tecnología para el desarrollo de aplicaciones es muy diversa y es recomendable aprovechar esa diversidad para elegir las herramientas más adecuadas para lo que requerimos.</p><p>Node.js, Elixir y Java(Reactor, Akka) son alternativas bastante buenas para iniciar un proyecto de software, pero conocer sus fortalezas y debilidades puede ahorrarnos muchos dolores de cabeza, especialmente a la hora de mantener una aplicación funcionando adecuadamente en producción.</p><p>¡Elige la opción que más se acomode al caso de uso que buscas resolver!</p><p><strong>Nota</strong>: Ten en cuenta que los resultados presentados anteriormente no son una comparación exhaustiva de herramientas, sino una serie de criterios que, desde nuestra experiencia, han sido útiles a la hora de elegir un stack tecnológico.</p><p>Tenemos claro que existen muchas más tecnologías válidas e interesantes que no abordamos en la comparación — sería imposible hacerlo en un sólo artículo — , así que priorizamos algunas de las que le apuntan a las necesidades particulares de Bancolombia.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=15dfa25764f6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/criterios-para-elegir-un-stack-tecnol%C3%B3gico-15dfa25764f6">Criterios para elegir un stack tecnológico</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Domain driven design en Bancolombia— De lo estratégico a lo táctico]]></title>
            <link>https://medium.com/bancolombia-tech/domain-driven-design-en-bancolombia-de-lo-estrat%C3%A9gico-a-lo-t%C3%A1ctico-6e71a7a81c3a?source=rss-d01e990a1e68------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e71a7a81c3a</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <dc:creator><![CDATA[Daniel Estiven Rico Posada]]></dc:creator>
            <pubDate>Tue, 24 Mar 2020 22:25:59 GMT</pubDate>
            <atom:updated>2021-02-01T13:13:24.455Z</atom:updated>
            <content:encoded><![CDATA[<p>La llegada de la nube hace que los negocios que usan tecnología para su funcionamiento tengan que transformarse. No solo presenta desafíos culturales, al ceder capacidades de infraestructura y de información a un tercero, sino que la nube replantea la forma en la que las aplicaciones deben construirse y nos llevan a pensarlas bajo el concepto de aplicaciones <strong><em>Cloud Native.</em></strong></p><p>Cuando pensamos en aplicaciones c<em>loud native </em>es natural considerar una transición hacia sistemas distribuidos, promoviendo necesariamente una forma distinta de pensar acerca de cómo construir, desplegar, escalar y mantener software.</p><blockquote>¿No sabes que son sistemas distribuidos? En este enlace te explican los principios básicos: <a href="https://dzone.com/articles/concepts-of-distributed-systems-part-1">https://dzone.com/articles/concepts-of-distributed-systems-part-1</a></blockquote><p>El caso de las entidades Bancarias como el <strong>Grupo Bancolombia</strong> no es distinto. Desde hace algunos años nos planteamos el reto de repensar la nueva generación de aplicaciones del banco, promoviendo una serie de prácticas en pro de tener un adecuado aprovechamiento de las nuevas capacidades de infraestructura que nos ofrece la nube.</p><p>Estas prácticas tienen como foco potenciar el negocio desde la construcción de capacidades tecnológicas responsivas (con tiempos de respuesta consistentes), costo eficientes y confiables.</p><h3>Diseño de software, ¿estructura o comportamiento? Los eventos son la clave…</h3><blockquote>“Object-Oriented Programming (OOP) taught us that we should begin our design sessions focusing on the things — the nouns — in the domain, as a way of finding the Domain Objects, and then work from there. It turns out that this approach has a major flaw: it forces us to focus on structure too early.” <em><br></em>(Bonér, J. (2017). Reactive Microsystems. O’Reilly Media, Inc.)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JygmVXoiL0fJ9KIB" /><figcaption>Photo by <a href="https://unsplash.com/@alain_pham?utm_source=medium&amp;utm_medium=referral">Alain Pham</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Como lo plantea Jonas Bonér y como es promovido desde la academia y la industria es inadecuado que, en nuestros primeros esfuerzos de diseño de software pensemos en los objetos necesarios para modelar un problema del mundo real, principalmente cuando lo que estamos diseñando son sistemas distribuidos.</p><p>Con lo anterior estoy completamente de acuerdo. Autores como Russ Miles también han criticado este enfoque, apoyando la idea de que <strong>la esencia para entender un dominio está en el flujo de los datos (eventos)</strong> y en una exploración basada en una perspectiva de comunicación y no tanto en las decisiones estructurales previas a las que nos vemos forzados a tomar, cuando pensamos sólo en objetos y relaciones — al menos en una fase inicial — . (Bonér, J. (2017). <a href="https://learning.oreilly.com/library/view/reactive-microsystems/9781491994368/ch04.html">Reactive Microsystems</a>. O’Reilly Media, Inc.)</p><p>Por esta razón, en la industria surgieron principios de diseño que probaron ser muy útiles para construir sistemas distribuidos a escala. Estos principios son necesarios, porque al volcarnos al mundo de los sistemas distribuidos, nos podemos encontrar con prácticas abstractas y apasionantes, pero frustrantes en algunas ocasiones.</p><p>Lo abstracto se presenta en la detección de fallas, latencia, escalabilidad, ordenamiento de los datos, trazabilidad y consistencia eventual. Estas situaciones las debemos aprender a manejar para aprovechar los beneficios que nos dan los sistemas distribuidos en cuanto a la construcción de soluciones resilientes y elásticas, en donde tener una arquitectura sólida se hace estrictamente necesario.</p><p>Este entendimiento a nivel de sucesos (eventos) nos permite comprender cómo los cambios se propagan en el sistema, sus dependencias y los responsables de los datos. Esta información es muy relevante para consolidar una base de conocimiento sólida para un equipo sobre un dominio.</p><p>Estos principios de diseño no sólo son herramientas para pensar en sistemas distribuidos, sino que también permiten reducir los efectos secundarios del inadecuado entendimiento que se ha dado sobre las metodologías ágiles.</p><h3>Diseño Efectivo y metodologías ágiles</h3><p>Las primeras metodologías de desarrollo plantearon que la manera adecuada de construir software era hacer un diseño detallado de cada componente antes de iniciar la más mínima implementación. Con el tiempo, la experiencia mostró que era una estrategia inadecuada, porque los requerimientos y retos van evolucionando. Eventualmente, llegó entonces “la solución”: el agilismo.</p><p>La llegada del agilismo y quizás, su mala interpretación, generó un problema que considero que es igual de grave a un diseño excesivo: <strong>la falta o inexistencia del diseño de software.</strong></p><p>Los equipos de desarrollo entraron en una dinámica de tomar tareas de un backlog que varía cada sprint e implementar el código que resuelve esa necesidad puntual, creando proyectos que dan una aparente sensación de velocidad hacia el negocio, pero que terminan siendo inmantenibles por no tener un norte claro a nivel de arquitectura.</p><p>DDD apoya el diseño efectivo de software evitando caer en procesos en cascada pero garantizando un norte claro a nivel de arquitectura, que sea coherente con procesos iterativos como los que plantean las metodologías ágiles.</p><h3><strong>Pero entonces, ¿qué es <em>Domain driven design</em> (DDD)?</strong></h3><p>DDD es un enfoque de desarrollo de software propuesto por Eric Evans en su libro:<strong> </strong><a href="https://www.amazon.com/dp/B00794TAUG/ref=cm_sw_em_r_mt_dp_U_zPPAEb9ZZ0YTY"><strong><em>Domain-Driven Design — Tackling Complexity in the Heart of Software</em></strong></a><em>. </em>Este enfoque busca una profunda conexión entre los conceptos y áreas del negocio y las arquitecturas aplicativas.</p><p>DDD tiene como objetivo facilitar el diseño e implementación de software que entregue alto valor a la organización, tanto desde un punto de vista estratégico como táctico, haciendo que los modelos de software reflejen las competencias core de la organización.</p><p>Una de las principales dificultades que es normal encontrarse en el proceso de entendimiento de DDD es: ¿cómo empezar a usarlo de manera práctica? debido a que inicialmente los conceptos suelen ser muy abstractos. Es importante saber qué DDD no es una tecnología ni tampoco una metodología.</p><p>La importancia de comprender que, DDD no es una metodología, es que, en sí mismo no ofrece una receta para un proceso de implementación paso a paso, sino más bien un marco de trabajo con diferentes herramientas utilizadas en diferentes fases del ciclo de desarrollo de software.</p><p>A continuación, presentaré las dos grandes fases que se plantean alrededor de <em>Domain Driven Design </em>y los beneficios específicos que hemos encontrado en cada una de ellas:</p><h3><strong>Modelado Estratégico</strong></h3><p>El modelado estratégico o DDD estratégico se enfoca en entender los diferentes contextos delimitados — y su lenguaje <em>ubicuo*</em> — los cuales tienen relación con el problema que se está modelando y busca agruparlos y clasificarlos en <em>subdominios core*</em>, de <em>soporte*</em> y <em>genéricos*</em>. Además, tiene como objetivo identificar los tipos de relaciones entre los <em>contextos delimitados*</em> para entender la dinámica del dominio.</p><p><strong>*Lenguaje ubicuo: </strong>es una práctica que consiste en construir un lenguaje común y riguroso entre el equipo de tecnología y los usuarios (equipo funcional) con el objetivo de evitar la ambigüedad.</p><p><strong>Contexto delimitado: </strong>son fronteras lógicas dentro de un modelo de dominio que cuentan con su propio lenguaje ubicuo.</p><p><strong>Subdominios core: </strong>es la suma de los contextos delimitados más críticos del negocio, es el factor diferenciador, la razón de ser del modelado que se está realizando.</p><p><strong>Subdominios de soporte: </strong>corresponde a los contextos delimitados que soportan funciones con relación directa al negocio pero a nivel de complemento.</p><p><strong>Subdominios genéricos: </strong>son subdominios que responden a capacidades genéricas que pueden funcionar de la misma forma para cualquier organización sin ningún tipo de especialización o adaptación a nivel de negocio.</p><p><strong>Un ejercicio de modelado estratégico debería permitirnos:</strong></p><ul><li>Crear un lenguaje ubicuo que pueda ser entendido tanto por el equipo de tecnología como por el equipo funcional, priorizando los conceptos propios del negocio.</li><li>Entender los subdominios impactados en una solución y la relevancia de cada uno de ellos desde un criterio de negocio.</li><li><strong>Tomar decisiones alrededor de la tercerización:</strong> los subdominios core nunca deben ser tercerizados, los subdominios de soporte deberían evaluarse desarrollarlos <em>in-house </em>y<em> </em>los subdominios genéricos deberían poder tercerizarse sin mayor impacto.</li><li><strong>Tomar decisiones relacionadas a las asignaciones de los equipos:</strong> los desarrolladores <em>senior</em> siempre deben trabajar en los dominios core. Los dominios adicionales pueden ser abordados por desarrolladores con menos experiencia.</li><li>Entender necesidades de negocio a alto nivel desde un modelado colaborativo, evitando los reprocesos que se generan al tener que contextualizar a varios equipos de la misma idea en espacios independientes.</li></ul><p><strong>¿Quién debería participar de las sesiones de modelado estratégico?</strong></p><ul><li>Arquitectos de Software</li><li>Expertos de dominio (negocio)</li><li>Líderes de tecnología involucrados</li></ul><p><strong>Y, ¿por dónde empiezo?</strong></p><p>Estos conceptos son más fáciles de materializar si nos apoyamos de técnicas que nos faciliten el trabajo. En el caso del <strong>modelado estratégico</strong> es útil revisar <strong>Context Mapping. </strong>Hay que tener en cuenta que estas son las herramientas con las que hemos tenido experiencia y nos han sido de gran utilidad. Sin embargo, lo importante es lograr obtener el mapa de contextos, por tanto, si conoces herramientas adicionales, es válido utilizarlas mientras se llegue al mismo resultado — <strong>estas herramientas adicionales puedes compartirlas en los comentarios para que sean de utilidad para todos</strong> — .</p><p>El resultado debería verse de la siguiente forma:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/1*9sChpd5jTESOt9TwDD9IUA.jpeg" /></figure><p>(Brandolini, A. (2009). <a href="https://www.infoq.com/articles/ddd-contextmapping/">Strategic Domain Driven Design with Context Mapping </a>. InfoQ)</p><h3>Modelado Táctico</h3><p>El modelado táctico es la siguiente fase del diseño orientado al dominio. Esta fase tiene como objetivo detallar las arquitecturas aplicativas y su materialización en código, siempre pensando en cuidar y aislar lo realmente relevante de una aplicación:<strong> el dominio</strong>.</p><p>A este nivel se busca un entendimiento detallado por parte del equipo de desarrollo de todos los flujos relevantes del negocio que serán materializados a través de la tecnología.</p><p>Las arquitecturas orientadas al dominio permiten materializar el modelo táctico en código, utilizando técnicas que aíslan y protegen al dominio de los detalles tecnológicos. Estos conceptos son tratados en detalle en este artículo:</p><p><a href="https://medium.com/bancolombia-tech/clean-architecture-aislando-los-detalles-4f9530f35d7a">Clean Architecture — Aislando los detalles</a></p><p><strong>¿Quién debería participar de las sesiones de modelado táctico?</strong></p><ul><li>Equipo implementador de la solución</li><li>Expertos de dominio (negocio)</li></ul><p><strong>Un ejercicio de modelado táctico debería permitirnos:</strong></p><ul><li>Entender y plasmar en un diagrama todos los flujos relevantes de negocio.</li><li>Tener un modelo de dominio claro y más refinado.</li><li>Tener una base clara sobre el tipo de arquitectura que utilizaremos.</li><li>Hacer una planeación inicial de la segregación a nivel de unidades desplegables del software a construir.</li><li>Estimar la infraestructura requerida.</li></ul><p><strong>Y, ¿por dónde empiezo?</strong></p><p>Para lograr identificar los flujos de negocio y facilitar la generación de un <strong>modelo de dominio</strong>, es de gran utilidad hacer uso de una herramienta conocida como <strong>Event Storming</strong>.</p><p>Esta herramienta — creada por Alberto Brandolini en el marco de DDD — tiene como objetivo acelerar a través de un <em>workshop </em>el descubrimiento y entendimiento de dominios de negocio a través de los elementos definidos en la siguiente imagen:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GFoLfdhB8a0oBmr0OoFggQ.png" /></figure><p>(Brandolini, A. (2019). Introducing to Event Storming. LeanPub)</p><p>Cuando se tienen identificados los diferentes contextos delimitados que surgen del taller, pueden considerarse como el primer acercamiento a la <strong>cantidad de unidades desplegables óptimas para una solución</strong>, que será complementado con los requerimientos no funcionales y con los retos transaccionales que una solución pueda tener.</p><p>Después de tener identificados los dominios de negocio y en una fase más cercana a la implementación, puedes <strong>utilizar este plugin Open Source que hemos construido en Bancolombia para acelerar el proceso de desarrollo</strong>, y que está alineado a los planteamientos de arquitectura limpia de Robert C Martin:</p><p><a href="https://github.com/bancolombia/scaffold-clean-architecture">GitHub - bancolombia/scaffold-clean-architecture: Gradle plugin to create a clean application in Java that already works, It follows our best practices!</a></p><p>En una etapa posterior, cuando ya tengas construidos algunos componentes y llegue la necesidad de<strong> planear la infraestructura requerida</strong>, es de gran utilidad hacer uso de esta herramienta para <strong>encontrar el momento de degradación de una aplicación</strong>, y que permite comprobar los principios planteados por la ley universal de la escalabilidad.</p><p>La idea es tener criterios para decidir las estrategias de escalamiento necesarias para soportar la transaccionalidad indicada en los requerimientos no funcionales del proyecto. La herramienta se enfoca en hacer pruebas de rendimiento desde nodos distribuidos:</p><p><a href="https://github.com/bancolombia/distributed-performance-analyzer">bancolombia/distributed-performance-analyzer</a></p><p>Espero que el artículo sea descriptivo en cuanto los beneficios que ofrece un enfoque de desarrollo como DDD. Los invito a que el próximo proyecto que emprendan lo realicen con esta orientación y a que contribuyan a las diferentes iniciativas <strong><em>open source</em></strong> que desde <strong>Bancolombia</strong> estamos liderando.</p><p>Como desarrolladores está en nuestras manos apoyar el crecimiento de comunidades <em>open source</em> en Colombia y en general en Latinoamérica. Considero que podemos inclinar la balanza y aportar cada vez más a la construcción de tecnología y no sólo al uso.</p><p><strong>Referencias Adicionales que me ayudaron en el proceso:</strong></p><ul><li><em>Clean Architecture (Robert C Martin)</em></li><li><em>Implementing Domain Driven Design (Vaughn Vernon)</em></li><li><em>Domain Driven Design Distilled</em></li><li><em>Event Storming (Alberto Brandolini)</em></li><li><em>Domain-Driven Design — Tackling Complexity in the Heart of Software</em></li><li><em>Reactive Microservices: Chapter 4 - Events First Domain Driven Design</em></li><li>Universal Scalability Law: <a href="https://cdn2.hubspot.net/hubfs/498921/eBooks/scalability_new.pdf?t=1449863329030">https://cdn2.hubspot.net/hubfs/498921/eBooks/scalability_new.pdf?t=1449863329030</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e71a7a81c3a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/domain-driven-design-en-bancolombia-de-lo-estrat%C3%A9gico-a-lo-t%C3%A1ctico-6e71a7a81c3a">Domain driven design en Bancolombia— De lo estratégico a lo táctico</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Guía práctica de autenticación basada en tokens para NodeJS]]></title>
            <link>https://medium.com/@danielrico.posada/gu%C3%ADa-pr%C3%A1ctica-de-autenticaci%C3%B3n-basada-en-tokens-para-nodejs-caccf2ba7efb?source=rss-d01e990a1e68------2</link>
            <guid isPermaLink="false">https://medium.com/p/caccf2ba7efb</guid>
            <category><![CDATA[middleware]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[rsa]]></category>
            <category><![CDATA[authentication]]></category>
            <category><![CDATA[jwt]]></category>
            <dc:creator><![CDATA[Daniel Estiven Rico Posada]]></dc:creator>
            <pubDate>Sun, 22 Sep 2019 22:36:07 GMT</pubDate>
            <atom:updated>2019-09-23T21:25:41.303Z</atom:updated>
            <content:encoded><![CDATA[<h4>Lo que necesita saber sobre JSON Web Tokens (JWT) para proteger APIS REST.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*l18iBP-C9W1L-gtF" /><figcaption>Photo by <a href="https://unsplash.com/@hidd3n?utm_source=medium&amp;utm_medium=referral">Kevin Horvat</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Tradicionalmente, las aplicaciones web han sido construidas con una arquitectura en donde el <em>back (servicios) </em>y el <em>front (vistas)</em> hacen parte de la misma aplicación. Este enfoque — bastante utilizado por muchos años — empezó a desvirtuarse un poco con la llegada de la Computación en la nube. Esta última, como grupo de tecnologías (utilizadas como servicio) han apalancado un concepto, que aunque para nada nuevo, está siendo tendencia gracias a la madurez y adopción de <em>cloud </em>en la actualidad: los microservicios.</p><p>Esta tendencia de microservicios, propone un manejo desacoplado del back en diferentes componentes, con el objetivo de ser escalados de manera independiente, basados en sus necesidades transaccionales o en la división a nivel de subdominios de quienes los van a construir.</p><p>Es muy probable que, por ejemplo, se requiera mayor capacidad a nivel de infraestructura para soportar los pagos de cientos de clientes en épocas de quincena, que para la consulta de los posibles productos bancarios que un cliente pueda adquirir desde el sitio web. Por esta razón, tiene más sentido en este escenario, construir 2 unidades desplegables independientes con su propia configuración de infraestructura, en vez de escalar un monolito completo innecesariamente.</p><p>En estas arquitecturas tradicionales, la autenticación suele basarse en el manejo de cookies o sesiones, en cambio, en las aplicaciones nativas de nube, en donde los componentes del back-end y del front-end viven en servidores independientes, es más común encontrar un manejo basado en tokens JWT.</p><p>Esta cambio de paradigma tiene un sentido, que está relacionada con el manejo de estado de las aplicaciones. Cuando se realiza una autenticación basada en tokens JWT, el contenido de cada request es suficiente para resolver cada recurso (componentes <em>stateless</em>), es decir, no se depende de una sesión creada dentro de la aplicación para dar respuesta a un request; permitiendo así, hacer un escalamiento horizontal de las aplicaciones sin tener inconvenientes al momento de balancear cargas hacia n instancias.</p><blockquote>JWT puede referirse a tokens firmados(JWS) o tokens cifrados(JWK). Este post se enfoca en el manejo de tokens firmados como estrategia para enviar información entre aplicaciones, garantizando que nadie la ha modificado durante la transmisión. Si su necesidad es el manejo de tokens cifrados, puede hacer uso de esta librería: <a href="https://www.npmjs.com/package/jwks-rsa">https://www.npmjs.com/package/jwks-rsa</a></blockquote><h4>Vamos al código…</h4><p>A continuación voy a explicar lo que desde mi experiencia ha sido más útil entender de los tokens JWT:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*G7apyHakTnTAbqkR" /><figcaption>Photo by <a href="https://unsplash.com/@goshua13?utm_source=medium&amp;utm_medium=referral">Joshua Aragon</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3><strong>¿Cómo genero un token JWT?</strong></h3><p>Una de las opciones más reconocidas en Node para firmar tokens JWT es la librería <strong>jsonwebtoken</strong>.</p><pre>$ npm install jsonwebtoken</pre><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/311bd3bca55e6bf703ed1d8b33d7be59/href">https://medium.com/media/311bd3bca55e6bf703ed1d8b33d7be59/href</a></iframe><p>Los tokens JWT se componen de tres secciones: un algoritmo de firmado, el payload (información) y la firma (llave que permite al receptor verificar que el mensaje no ha sido modificado durante la transmisión).</p><p>Cuando no se especifica el algoritmo a utilizar (como en la anterior implementación), por defecto es utilizado un algoritmo<strong> </strong>llamado<strong> HMAC SHA256</strong>. Este algoritmo es simétrico, lo que obliga a cada una de las partes (emisor y receptor) a conocer la llave privada con la que fue firmado el token para poder verificarlo. Este algoritmo, aunque útil en algunos escenarios, desde mi experiencia no es el más común.</p><p>Es más común encontrarse con un escenario en donde se requiera un algoritmo asimétrico, es decir, quien genera el token es el único que conoce su llave privada, y quién necesite verificar el token, pueda hacerlo a través de la llave pública -escenario utilizado por la mayoría de servicios de manejo de identidad (por ejemplo: Azure Active Directory, Cognito, Auth0)-.</p><p>Uno de los algoritmos asimétricos más utilizados es <strong>RSA 256.</strong></p><h3>¿Cómo firmo un token JWT con RSA 256?</h3><p>Lo primero que requiere es generar una llave pública y una llave privada con RSA:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/87cb60edec8aaca29d24e18bc8e5313e/href">https://medium.com/media/87cb60edec8aaca29d24e18bc8e5313e/href</a></iframe><p>Lo anterior debe haber generado dos archivos:<strong> jwtRS256.key</strong> (llave privada) y <strong>jwtRS256.key.pub </strong>(llave pública) que serán utilizados para la implementación usando jsonwebtoken:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9b095811c0d97b16757085cc70d2f6ee/href">https://medium.com/media/9b095811c0d97b16757085cc70d2f6ee/href</a></iframe><h3>¿Cómo verifico un token JWT firmado con RSA 256?</h3><p>La forma de verificar tokens JWT firmados con un algoritmo asimétrico como RSA, es usando la llave pública. En nuestro caso será usando la llave que está dentro del archivo jwtRS256.key.pub:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7289e7c20ed96b05f07cff4a24c3151d/href">https://medium.com/media/7289e7c20ed96b05f07cff4a24c3151d/href</a></iframe><h3>¿Puedo ver el contenido de un token JWT sin tener la llave pública?</h3><p>Si. La misión de los tokens JWS es garantizar que la información que es enviada desde el emisor hasta el receptor no sea modificada durante la transmisión. Esto no quiere decir que esta información vaya cifrada, por el contrario, quien obtenga un token JWT puede ver todo su contenido, lo cual no debería ser un problema si se está utilizando esta estrategia.</p><p>Para ver el contenido de un token JWT puede copiarlo e ingresar al sitio:</p><p><a href="https://jwt.io/">JSON Web Tokens - jwt.io</a></p><h3>¿Cuando expiran los tokens?</h3><p>Si no se define nada alrededor de la expiración, los tokens generados nunca vencen. La forma de establecer la duración es a través del atributo “expiresIn” al momento de realizar la firma del token:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/95fedc1e7d4776f417edd64a3d81695a/href">https://medium.com/media/95fedc1e7d4776f417edd64a3d81695a/href</a></iframe><p>El atributo “expiresIn” está dado en segundos, por tanto, en la anterior implementación el token durará una hora. También es posible indicar este valor en otras unidades, como por ejemplo “1h” o “150ms”.</p><h3>¿Qué es la audiencia y cómo se define?</h3><p>Imagine un escenario donde está construyendo su propio servicio de manejo de identidad. Su objetivo es que diferentes aplicaciones utilicen su servicio para manejar la autenticación basada en tokens JWT. Dado que usted emite los tokens con la misma llave privada RSA, si alguien genera un token en la aplicación A, este también será un token válido para la aplicación B, lo cual estaría dejando expuestas todas las aplicaciones que usan su servicio a una vulnerabilidad grave.</p><p>La audiencia de los tokens busca mitigar esta vulnerabilidad, haciendo que cuando se emita un token, se indique para quién fue generado. Por tanto, si se emite un token para la aplicación A no podrá ser utilizado para consumir recursos de la aplicación B.</p><p>En muchas ocasiones en la audiencia se define el clientId de la aplicación para la cual se está generando el token (pero en realidad puede ser cualquier String).</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/47a8fcd42b681fb6ab7da0ee4110fa87/href">https://medium.com/media/47a8fcd42b681fb6ab7da0ee4110fa87/href</a></iframe><p>Si verifica el token en el sitio jwt.io, podrá darse cuenta que tiene dos atributos nuevos, uno asociado a la expiración (exp) y otro a la audiencia (aud).</p><p>Para verificar un token que tiene audiencia, debe indicarlo explícitamente en la implementación:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/da53c832cf15fdb5017fd6803cc8b5cd/href">https://medium.com/media/da53c832cf15fdb5017fd6803cc8b5cd/href</a></iframe><h3>Atributos adicionales…</h3><p>Existen atributos adicionales que pueden ser utilizados en caso de que se requieran, como por ejemplo:</p><ul><li>issuer: definir un emisor de los tokens</li><li>iat: Indicar el momento (fecha) en que el token empieza a ser válido.</li><li>keyid: hace referencia a la ubicación de una llave pública dentro de un pool de llaves (común en servicios de manejo de identidad)</li></ul><h3>¿Cómo protejo una API REST con JWT?</h3><p>Cada petición que se envíe desde un front hacia las APIS Rest protegidas, debe contener un header de autorización del estilo:</p><p><strong>Authorization:</strong> Bearer &lt;token&gt;</p><p>A continuación, vamos a implementar un middleware que pueda ser utilizado en diferentes APIS Rest para la verificación de los tokens JWT:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b2d391c3c151800fc064af0b095bf982/href">https://medium.com/media/b2d391c3c151800fc064af0b095bf982/href</a></iframe><p>Ahora vamos a implementar una API Rest que responda un arreglo de objetos estáticos, y que a través de un middleware verifique si el token enviado es válido o no.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/642ae638661d1f32dd5a4c5fa63f4c30/href">https://medium.com/media/642ae638661d1f32dd5a4c5fa63f4c30/href</a></iframe><p>El repositorio con la implementación completa lo pueden encontrar en:</p><p><a href="https://github.com/dericop/node-jwt-rsa">dericop/node-jwt-rsa</a></p><p>Espero les haya sido de utilidad esta publicación.</p><p>Cualquier mejora que tengan en mente, el repositorio queda abierto para que envíen sus <em>pull-requests</em> :D.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=caccf2ba7efb" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>