<?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 John Mauricio Carmona Escobar on Medium]]></title>
        <description><![CDATA[Stories by John Mauricio Carmona Escobar on Medium]]></description>
        <link>https://medium.com/@maocq?source=rss-ab86bcc0b21------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*zsRSpbbAOXmQT8TkN-JDiQ.jpeg</url>
            <title>Stories by John Mauricio Carmona Escobar on Medium</title>
            <link>https://medium.com/@maocq?source=rss-ab86bcc0b21------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 20:52:01 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@maocq/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[Cómo mejorar el rendimiento de nuestras aplicaciones]]></title>
            <link>https://medium.com/bancolombia-tech/c%C3%B3mo-mejorar-el-rendimiento-de-nuestras-aplicaciones-909de832b0c?source=rss-ab86bcc0b21------2</link>
            <guid isPermaLink="false">https://medium.com/p/909de832b0c</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[latency]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[elixir]]></category>
            <category><![CDATA[performance]]></category>
            <dc:creator><![CDATA[John Mauricio Carmona Escobar]]></dc:creator>
            <pubDate>Fri, 28 Oct 2022 22:20:20 GMT</pubDate>
            <atom:updated>2022-10-28T22:20:20.281Z</atom:updated>
            <content:encoded><![CDATA[<h4>Pool de conexiones http (Elixir, Go y Java)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*nRqhcKcp9ynAgQxBcorhiw.png" /></figure><p>En el siguiente artículo revisaremos cómo podemos mejorar el rendimiento de nuestras aplicaciones a partir de optimizar uno de los puntos importantes dentro del desarrollo de software, como lo es la comunicación con servicios externos.</p><p>Es común encontrarnos casos de uso donde requerimos comunicarnos con diferentes servicios mediante distintos protocolos. Uno de los más usados es HTTP donde, por ejemplo, podemos apoyarnos de dicho protocolo para comunicarnos con una aplicación financiera o hasta algo simple cómo la consulta de información.</p><p>Veremos a continuación algunos de los aspectos que debemos tener en cuenta al momento de realizar dicha comunicación, con el fin de sacar el mayor provecho de los recursos y obtener un mejor rendimiento.</p><p>Antes de iniciar veamos un poco cómo funciona HTTP/HTTPS y las principales diferencias de su versiones 1 y 2.</p><p>La siguiente imagen nos dará claridad desde el entendimiento de lo que involucra una petición HTTP y los diferentes bloques que la componen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bMOE_y-aAsEUAWsl1vr6OQ.png" /><figcaption>(<a href="https://blog.bytebytego.com/">https://blog.bytebytego.com/</a>)</figcaption></figure><p>En la anterior imagen podemos ver a grandes rasgos los siguientes pasos:</p><ol><li>Negociación TCP (<a href="https://es.wikipedia.org/wiki/Protocolo_de_control_de_transmisi%C3%B3n">handshake</a>),</li><li>Verificación de certificado</li><li>Intercambio de llaves.</li><li>Transmisión de datos</li></ol><p>Puedes ampliar más información de cómo funciona HTTPS <a href="https://blog.bytebytego.com/p/how-does-https-work-episode-6">aquí</a>.</p><h3><strong>HTTP/1 y HTTP/2</strong></h3><p>Una de las principales diferencias que hay entre la versión 1 y 2 del protocolo HTTP es que en HTTP/2 las conexiones pueden ser inmediatamente reusadas pero en HTTP/1 la petición debe ser completada antes de que la conexión pueda ser reusada.</p><p>Por otro lado, HTTP/2 nos permite el uso de protocolo binario en la transmisión de información.</p><p>A continuación iremos explorando cómo podemos hacer uso de dichos protocolos en diferentes lenguajes, revisando cada una de sus particularidades y encontrando similitudes que nos permitan ayudar a entender mejor.</p><p><em>Las pruebas a continuación serán ejecutadas en ambientes aislados usando instancias c5.large. Puedes consultar el código usado en el siguiente </em><a href="https://github.com/maocq/http-pool-connections"><em>link</em></a><em>.</em></p><h3><strong>Elixir</strong></h3><p>Para Elixir no escribiremos desde cero nuestra conexión, por el contrario usaremos <a href="https://github.com/elixir-mint/mint">Mint</a> cómo cliente HTTP.</p><p>Mint se basa en una estructura de datos funcional e inmutable que representa una conexión HTTP.</p><p>Al usar Mint tendríamos un código cómo este:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/735a56ff8f9b6d478ada17ab9165a002/href">https://medium.com/media/735a56ff8f9b6d478ada17ab9165a002/href</a></iframe><p>(<a href="https://github.com/maocq/http-pool-connections/blob/master/elixir-ms/lib/infraestructure/driven-adapters/http/http_client.ex">Ver código completo</a>)</p><p>Podemos resumir el código anterior en los siguientes pasos:</p><ol><li>Iniciar la conexión</li><li>Realizar petición</li><li>Manejar la respuesta</li><li>Cerrar la conexión</li></ol><p><em>Note como en el anterior código no hacemos uso de un pool de conexiones, por el contrario cada petición crea su respectiva conexión.</em></p><h4><strong>Resultados</strong></h4><p>Las gráficas a continuación nos mostrarán el resultado de las transacciones por segundo (tps) soportadas por el servicio durante 5 minutos de carga (Más alto mejor).</p><p>Primero veamos cómo se comporta nuestra aplicación al conectarse con un servicio por http (no https), donde podríamos resumir que solo se realizará la Negociación TCP y la transmisión de datos sin cifrar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/265/1*wy2RJXKCP3qKAaSYM49Low.png" /><figcaption>Latencia de 10 ms</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/263/1*g2ywg6t_Z0CTLwcbmrHXMw.png" /><figcaption>Latencia de 100 ms</figcaption></figure><p>En las gráficas anteriores observamos como la latencia del servicio no afecta los resultados. En promedio unas casi 3.000 transacciones por segundo. Esto se debe a que cada petición es independiente y no tiene que interactuar dentro de un pool de conexiones.</p><p>Pero qué pasa si la conexión debe ser por HTTPS, y por lo tanto ejecutar pasos adicionales como la verificación de certificado, intercambio de llaves y cifrado de información.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/290/1*h--dGjoNHRvk9NJAZtd1Zg.png" /><figcaption>Latencia de 100 ms</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/293/1*faKNqTCmcPEaiPY_NImYKg.png" /><figcaption>Latencia de 1.000 ms</figcaption></figure><p>Igual que en el caso anterior la latencia del servicio no afecta el comportamiento, pero por otro lado el rendimiento baja considerablemente a en promedio 300 transacciones por segundo (casi 10 veces menos que con http).</p><p><em>Realmente los temas relacionados con la seguridad no son negociables y, aunque a veces estamos en la misma red privada que el servicio que consumimos y podríamos usar http, esto no aplica en la mayoría de casos.</em></p><p>Pero entonces ¿Cómo podemos mejorar nuestro rendimiento si debemos comunicarnos por HTTPS?</p><h3><strong>Pool de conexiones</strong></h3><p>Un pool de conexiones es un conjunto limitado de conexiones ,de forma tal que dichas conexiones pueden ser reutilizadas y no tener que ser creadas cada vez que sean requeridas.</p><p>Un pool de conexiones http nos ayuda a mejorar el rendimiento de nuestras aplicaciones ya que las conexiones son rehusadas, evitándonos en cada ocasión tener que realizar la negociación TCP, la verificación de certificado, intercambio de llaves y solo centrarnos en la transmisión de datos.</p><p>Ahora realicemos las mismas pruebas pero esta vez usando un pool de conexiones y veamos qué ocurre.</p><p>Para estos escenarios de uso de Pool de conexiones nos apoyaremos en <a href="https://github.com/sneako/finch">Finch</a>.</p><p>Finch es un cliente HTTP centrado en el rendimiento y construido sobre Mint y Nimble Pool. Nos proporciona estrategias eficientes de agrupación de conexiones evitando la copia siempre que sea posible.</p><p>Su forma de uso es bastante sencilla. Debemos iniciar Finch dentro del árbol de supervisión de nuestra aplicación asignándole un nombre; para nuestro ejemplo <em>HttpFinch</em>.</p><pre>def application_children(_other_env),<br>    do: [<br>      # ...<br>      {Finch, name: HttpFinch, pools: %{:default =&gt; [size: 100]}}<br>    ]</pre><p>(<a href="https://hexdocs.pm/finch/Finch.html">Configuración adicional para Finch</a>)</p><p>Finch nos permite además manejar diferentes configuraciones</p><pre>{Finch,<br>   name: HttpFinch,<br>   pools: %{<br>     :default =&gt; [size: 10],<br>     &quot;<a href="https://hex.pm/">https://hex.pm</a>&quot; =&gt; [size: 32, count: 8]<br>   }}</pre><p>Y ahora podemos usarlo fácilmente a través del nombre que asignamos anteriormente.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7e42b404c503a743441fb9c654b14747/href">https://medium.com/media/7e42b404c503a743441fb9c654b14747/href</a></iframe><p><em>El tipo de conexión de Finch por defecto es HTTP/1</em></p><p>Ejecutemos nuevamente nuestras pruebas y veamos los nuevos resultados</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/291/1*aIdk26m1rMd4e2m-7BOu4w.png" /><figcaption>Pool de 100 conexiones y latencia de 10 ms.</figcaption></figure><p>En la gráfica anterior vemos cómo usando un pool de 100 conexiones logramos un aumento del rendimiento de casi 10 veces, pasando de 400 a 4.000 transacciones por segundo sobre HTTPS.</p><p>Lastimosamente no todo es tan sencillo cómo crear un pool con un número de conexiones fijo, hay otras cosas que debemos tener presentes.</p><p>Pero… ¿y si la latencia aumenta?</p><p>Aumentemos la latencia de 10 ms a 100 ms y veamos qué ocurre</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/260/1*4qxAArf0nZ2S5ytbvJ5YQA.png" /><figcaption>Latencia 100 ms</figcaption></figure><p>Bueno, seguimos teniendo un rendimiento mejor al que veíamos al no usar un pool de conexiones sobre HTTPS, y si tenemos latencias inferiores a 100 ms estaríamos ganando un mayor rendimiento.</p><p>Continuemos aumentando la latencia:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/263/1*EIkO6Gc9FRdbOimhls4sqQ.png" /><figcaption>Latencia 500ms</figcaption></figure><p>Y ahora un poco más de latencia:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/267/1*qJRC3fLEfhV9sptIKfesVQ.png" /><figcaption>1.000 ms</figcaption></figure><p>Hasta aquí vemos cómo realmente el comportamiento se vuelve fácil de predecir cuando tenemos aumento de latencia.</p><p>Si tenemos un pool de <strong><em>N</em> </strong>conexiones (<strong>N </strong>= 100), y cada conexión tarda en liberarse <strong><em>X</em> </strong>tiempo (<strong>X </strong>= 1 segundo), tendremos <strong><em>N</em> </strong>transacciones en <strong><em>X</em> </strong>tiempo (100 transacciones por segundo).</p><p>Otro ejemplo: Si la petición tarda 500 ms (½ segundo), con un pool de 100 conexiones tendremos un rendimiento de 200 transacciones por segundo, y así sucesivamente.</p><p>Ahora aumentemos el número de conexiones y veamos qué ocurre:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/809/1*twte1ws4XMPJeKXWPYddyw.png" /><figcaption>Pool de 200 conexiones</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*IB0nU0WWPrr2KqUgmXxEGg.png" /><figcaption>Pool de 500 conexiones</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/798/1*oVmIh5FRPHl1O7gEcQyumg.png" /><figcaption>Pool de 1.000 conexiones</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/799/1*IAIn_M5eEJaD5rl8AY_5Vw.png" /><figcaption>Pool de 2.000 conexiones</figcaption></figure><p>En este punto podríamos concluir que, si tenemos latencias bajas usando un pool de conexiones logramos aumentar nuestro rendimiento. Además, después de un cierto número de conexiones dentro del pool vemos cómo no ganamos rendimiento en bajas latencias, pero si las latencias aumentan tendremos un mayor número de conexiones para atender.</p><p>Aumentar nuestro pool nos puede incurrir en aumentos de memoria y uso de más recursos y si tenemos un número muy alto de conexiones dentro del pool podríamos afectar otras partes de nuestra aplicación.</p><h4>HTTP/2</h4><p>Cómo mencionábamos anteriormente en HTTP/2 las conexiones pueden ser inmediatamente reusadas (multiplexación) pero para usar dicho tipo de conexión debemos especificarlo de forma explícita a Flinch por medio del atributo ‘<em>protocol’</em></p><pre>{Finch, name: HttpFinch, pools: %{:default =&gt; [protocol: :http2,]}}</pre><p>Ejecutemos nuevamente nuestras pruebas</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-gBV7wtV5CVu-2lbzDJw0g.png" /></figure><p>Aquí debemos tener en cuenta que si el servicio que estamos consumiendo no soporta HTTP/2 obtendremos un error.</p><p>Una de las ventajas de usar HTTP/2 en Elixir es que nos podemos despreocupar de la latencia del servicio que estamos consumiendo obteniendo un rendimiento considerablemente bueno.</p><h4><strong>Solución de errores HTTP/2 con Finch</strong></h4><p>Si tenemos una alta concurrencia puede ser que nos encontremos con el siguiente error:</p><pre>[error] Error get hello %Mint.HTTPError{module: Mint.HTTP2, reason: :too_many_concurrent_requests}</pre><p>Puede solucionar dicho error aumentando el atributo <em>count:</em></p><pre>{Finch, name: HttpFinch, pools: %{:default =&gt; [protocol: :http2, count: &lt;number&gt;]}}</pre><p>Hasta aquí la información es clara, pero ¿esto ocurre sólo en Elixir?</p><p>Antes de pasar a las conclusiones veamos que ocurre en otros stacks tecnológicos.</p><h3><strong>Java reactivo (Webflux)</strong></h3><p>El cliente web reactivo para webfux ‘WebClient’ por defecto nos entrega un pool de conexiones configurado. Veremos un poco más adelante estos valores por defecto y cómo podemos cambiar su configuración.</p><p>Seguiremos la misma ruta de pruebas que ejecutamos en Elixir con el fin de tener una estructura de resultados similar.</p><p>Como mencionamos hace un momento, ‘WebClient’ viene por defecto con un pool de conexiones donde, para probar escenarios de no uso de pool de conexiones y por cada petición crear una nueva conexión, debemos de apoyarnos en ‘ConnectionProvider.newConnection()’ de la siguiente forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d918dc0e90c798a3039a2cd86d27539a/href">https://medium.com/media/d918dc0e90c798a3039a2cd86d27539a/href</a></iframe><p>Ahora estamos listos para ejecutar el primer escenario donde nos conectaremos a un servicio http sin hacer uso del pool de conexiones.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/722/1*s2ELGt_HtHFK-vO3Gz6X8A.png" /></figure><p>Y ahora al mismo servicio sobre HTTPS:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/1*q9s_15S1c88SN1kfGxKmAA.png" /></figure><p>Hagamos un paréntesis aquí para ver que los resultados tienen un comportamiento igual que los resultados que veíamos en Elixir.</p><p>Ahora hagamos uso del pool de conexiones:</p><pre>ConnectionProvider provider =<br>                ConnectionProvider.builder(&quot;name&quot;)<br>                        .maxConnections(&lt;poolSize&gt;)<br>                        .build();</pre><pre>new ReactorClientHttpConnector(HttpClient.create(provider))<br>...</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/767/1*KYUJjAANBLbd8CB4PXBemg.png" /><figcaption>Pool de 100 conexiones</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/758/1*BEndQ0nrojyYDGnx9DAO6g.png" /><figcaption>Pool de 500 conexiones</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/798/1*oqJfNw5K9X1xsYjP4Ad0yA.png" /><figcaption>Pool de 1.000 conexiones</figcaption></figure><p>Continuamos observando un comportamiento similar al visto en Elixir.</p><h4>HTTP/2</h4><p>Para hacer usos de HTTP2 al momento de crear nuestro HttpCliente debemos especificar dicho protocolo.</p><pre>HttpClient client =<br>        HttpClient.create()<br>                .protocol(HttpProtocol.H2)<br>                .secure();</pre><p>Cabe anotar que además podemos asignar ambos protocolos, y si en la etapa de negociación el servicio externo no soporta uno, el otro será usado.</p><pre>.protocol(HttpProtocol.H2, HttpProtocol.HTTP11)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qEhCvz6hfMjfcExiT8YO-w.png" /></figure><p>En este momento no nos detendremos a hablar mucho de estos resultados, ya que, como vemos tenemos el mismo comportamiento que Elixir y por tanto las mismas conclusiones que veíamos anteriormente.</p><p><strong>Pool de conexiones por defecto</strong></p><p>Hace un momento decíamos que WebClient nos entrega un pool de conexiones por defecto. Veamos cuál es su configuración.</p><p>El tamaño del pool por defecto es de 500 conexiones y podemos comprobar esto en la clase TcpResources.java en la llamada del método <em>ConnectionProvider.create</em></p><p>reactor.netty.tcp.TcpResources.java</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c910278ff3e6b76bdc1b65971eba367d/href">https://medium.com/media/c910278ff3e6b76bdc1b65971eba367d/href</a></iframe><p>Aquí es importante anotar algo, hay dos valores importantes a tener en cuenta en la configuración. El primero es ‘<em>maxConnections</em><strong><em>’ </em></strong>y el segundo <strong><em>’</em></strong><em>pendingAcquireMaxCount</em><strong><em>’</em></strong>.</p><p>Cómo veíamos anteriormente <strong><em>’</em></strong><em>maxConnections</em><strong><em>’</em> </strong>por defecto es de 500 y <strong><em>’</em></strong><em>pendingAcquireMaxCount</em><strong><em>’</em></strong><em> </em>es por defecto (‘<em>maxConnections’</em> * 2) = 1000.</p><p><strong><em>pendingAcquireMaxCount</em>:</strong> Es el número máximo de solicitudes registradas para adquirir para mantener en una cola pendiente. Cuando se invoca con -1, la cola pendiente no tendrá límite superior.</p><p>Lo anterior nos indica que podemos tener un total de 500 peticiones en ejecución y otras 1000 más esperando a ser atendidas. A partir de ese límite las peticiones serán rechazadas con el error PoolAcquirePendingLimitException.</p><pre>org.springframework.web.reactive.function.client.WebClientRequestException: Pending acquire queue has reached its maximum size of 1000; nested exception is reactor.netty.internal.shaded.reactor.pool.PoolAcquirePendingLimitException: Pending acquire queue has reached its maximum size of 1000<br>        <br>// …<br>Caused by: reactor.netty.internal.shaded.reactor.pool.PoolAcquirePendingLimitException: Pending acquire queue has reached its maximum size of 1000<br>        at reactor.netty</pre><p>El anterior problema puede ser solucionado aumentando el tamaño del valor de <em>pendingAcquireMaxCount </em>o asignando un -1 que indicará que no tendrá un límite.</p><pre>ConnectionProvider provider =<br>        ConnectionProvider.builder(&quot;custom&quot;)<br>                .maxConnections(poolSize)<br>                .pendingAcquireMaxCount(-1)<br>                .build();</pre><pre>return new ReactorClientHttpConnector(HttpClient.create(provider)  // ...</pre><p>Recuerde que en estos escenarios estará usando más memoria y lo que puede implicar el tener que tener una cola más grande de procesos en espera.</p><h3><strong>Go</strong></h3><p>Ahora revisaremos que pasa en Go Lang.</p><p>En Go nos apoyaremos del paquete <em>net http</em> de la librería estándar. El paquete http nos proporciona implementaciones de servidor y cliente HTTP.</p><p>En Go las cosas son un poco más sencillas ya que al usar el paquete http tendremos un pool de conexiones y además por defecto en la etapa de negociación si el servidor soporta HTTP/2, dicha versión será usada.</p><p>El código se vería algo más o menos así:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2642928022d3fcb2d96ac9d80c75035f/href">https://medium.com/media/2642928022d3fcb2d96ac9d80c75035f/href</a></iframe><p>Ahora veamos los resultados:</p><h4>HTTP/2</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*-dY9T_hHR-GnLsOqbMAo5g.png" /></figure><p>Go es uno de los lenguajes que nos ofrece un mejor rendimiento al trabajar con HTTP/2 y además facilidad de uso ya que el paquete <em>http</em> hace todo por nosotros.</p><h4>HTTP/1</h4><p>Cuando nuestro servicio externo no soporta HTTP/2 debemos tener en cuenta los siguientes valores que podemos configurar dentro del pool de conexiones.</p><p><strong>MaxIdleConns: </strong>Controla la cantidad máxima de conexiones inactivas (keep-alive) en todos los hosts. Cero significa sin límite.</p><p><strong>MaxConnsPerHost:</strong> Limita opcionalmente la cantidad total de conexiones por host, incluidas las conexiones en los estados de marcado, activo e inactivo. En caso de violación del límite, los diales se bloquearán. Cero significa sin límite.</p><p><strong>MaxIdleConnsPerHost:</strong> Si no es cero, controla el máximo de conexiones inactivas (keep-alive) para mantener por host. Si es cero, se usa DefaultMaxIdleConnsPerHost. = 2</p><p><strong>IdleConnTimeout: </strong>Es la cantidad máxima de tiempo que una conexión inactiva (keep-alive) permanecerá inactiva antes de cerrarse. Cero significa sin límite.</p><p>Con la siguiente configuración tendríamos el mismo comportamiento que en Elixir y Java reactivo, teniendo un pool de conexiones con un tamaño fijo.</p><pre>t := http.DefaultTransport.(*http.Transport).Clone()<br>t.MaxIdleConns = 0<br>t.MaxConnsPerHost = 500<br>t.MaxIdleConnsPerHost = 500<br>t.IdleConnTimeout = 90 * time.Second</pre><pre>return &amp;http.Client{<br>        Transport: t,<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/805/1*MuuLUwwachapm7FuAJ3ykA.png" /><figcaption>Pool de 200 conexiones</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/773/1*FsP9BkWDgxWJ1qMTv9GLyw.png" /><figcaption>Pool de 500 conexiones</figcaption></figure><p>En Go adicional podríamos hacer uso del pool de conexiones de una forma diferente, configurando un número de conexiones inactivas que pueden ser reusadas y adicionalmente no asignar un límite al número de conexiones por host de la siguiente forma:</p><p>(También podríamos configurar un valor alto en dicho atributo)</p><pre>t := http.DefaultTransport.(*http.Transport).Clone()<br>t.MaxIdleConns = 0<br>t.MaxConnsPerHost = 0<br>t.MaxIdleConnsPerHost = 500<br>t.IdleConnTimeout = 90 * time.Second</pre><pre>return &amp;http.Client{<br>        Transport: t,<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nMKzHscpRKxCHKEoZ0N_ag.png" /><figcaption>HTTPS/1 - MaxIdleConnsPerHost 100 y MaxConnsPerHost 0</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rbx4AeMiSD7peVqZlk8Vsg.png" /><figcaption>HTTPS/1 - MaxIdleConnsPerHost500 y MaxConnsPerHost 0</figcaption></figure><p>Aquí debemos anotar que aunque la configuración anterior nos entrega un buen rendimiento, en entornos de bajas latencias con un pool con un número fijo de conexiones podríamos obtener un mejor rendimiento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dQu-LLiVWlwqN4pMaGWUzA.png" /><figcaption>HTTPs/1 — MaxIdleConnsPerHost 500 y MaxConnsPerHost 500</figcaption></figure><h3><strong>Java spring boot (Tomcat)</strong></h3><p>Java en sus stacks bloqueantes es un poco diferente, en estos escenarios lo realmente importante no es tanto el pool de conexiones http que manejamos en nuestro cliente web; en este caso es más importante el número de threads que nuestro servidor tenga configurados y que representa el número máximo de subprocesos que se pueden ejecutar en un momento dado.</p><p>Para el caso de Tomcat (maxThreads) 200 es su valor por defecto, pero podemos modificarlos de la siguiente forma:</p><pre>server:<br>  tomcat:<br>    threads:<br>      max: 200</pre><p>Realmente el tema no es tan sencillo cómo solo aumentar el valor de nuestro maxThreads, esto ya que dependerá de varios factores como por ejemplo los recursos que la máquina tenga y las operaciones que nuestros servicios deba realizar.</p><p>En los ejemplos a continuación estaremos haciendo uso de okhttp como cliente http quién se encargara de manejar las conexiones externas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jOEzv5KT7ZqsRUYoOdarhg.png" /><figcaption>maxThreads = 200</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uSZhKtae7RYdcF0bN1oNvg.png" /><figcaption>maxThreads = 500</figcaption></figure><p>Pero veamos qué pasa si continuamos aumentando el número de conexiones (pool) soportadas por nuestro servidor Tomcat.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GfJPEVZSU-EfDVZFTw7XsA.png" /><figcaption>Latencia de 500 ms</figcaption></figure><p>Podemos ver como al aumentar el número de peticiones que podemos atender, nuestro rendimiento empieza a disminuir lo que además nos permite comprobar los principios planteados por la ley de escalabilidad.</p><h3><strong>Conclusiones</strong></h3><ul><li>Una de las primeras cosas que debemos recordar es que, aunque los resultados anteriores nos entregan unos datos base, no existe una solución general y conocer las características que tienen sus servicios externos llevarán a una mejor solución.</li><li>Así como para la base de datos, usar un pool de conexiones nos entrega un mejor rendimiento pero la latencia del servicio externo es un factor importante a tener en cuenta y que puede cambiar la estrategia a utilizar.</li><li>Si el servicio con el que debe comunicarse ofrece latencias altas o un bajo rendimiento podría optar por estrategias asíncronas donde puede apoyarse de una arquitectura orientada a eventos.</li><li>Separar en diferentes pool de conexiones dependiendo del servicio que estemos consumiendo nos permitirá trabajar fácilmente con diferentes requerimientos.</li><li>Un buen monitoreo nos puede entregar información valiosa que nos ayude a configurar mejor nuestras aplicaciones.</li><li>Los escenarios descritos anteriormente describen escenarios de alta concurrencia. Si su solución no necesita soportar una gran cantidad de transacciones por segundo puede optar fácilmente por la solución más sencilla.</li></ul><p>Gracias.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=909de832b0c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/c%C3%B3mo-mejorar-el-rendimiento-de-nuestras-aplicaciones-909de832b0c">Cómo mejorar el rendimiento de nuestras aplicaciones</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[Benchmark de tecnologías Backend]]></title>
            <link>https://medium.com/bancolombia-tech/benchmark-de-tecnolog%C3%ADas-backend-dd1342e84152?source=rss-ab86bcc0b21------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd1342e84152</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[elixir]]></category>
            <category><![CDATA[java11]]></category>
            <dc:creator><![CDATA[John Mauricio Carmona Escobar]]></dc:creator>
            <pubDate>Mon, 24 Oct 2022 17:16:50 GMT</pubDate>
            <atom:updated>2022-10-24T17:16:50.592Z</atom:updated>
            <content:encoded><![CDATA[<h4>Probando escenarios cercanos a la realidad</h4><p>El siguiente benchmark tiene como objetivo validar el rendimiento de diferentes stacks tecnológicos. Pretende lograr una comparación un poco más cercana a la realidad, no solo realizar la ejecución de escenarios simples, sino replicar escenarios más cercanos a los que día a día tenemos que enfrentar, en donde la interacción con otros sistemas toma relevancia y la latencia es un factor importante.</p><p>Pretendemos además hacer que el <em>benchmark</em> pueda ser fácilmente replicable, con el fin de validar diferentes escenarios y garantizar que el comportamiento presentado sea un resultado confiable y no el producto de la aparición de un comportamiento puntual.</p><p>Los resultados que veremos a continuación no pretenden tener la última palabra al momento de tomar la decisión de que stack tecnológico usar. Lo anterior ya que se deben tener en cuenta otros criterios importantes como el nivel de concurrencia, estilo de programación, experiencia del equipo, curva de aprendizaje, entre otros. Para lo anterior recomendamos leer el siguiente artículo.</p><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></p><p>Los stacks que pondremos a prueba en el siguiente benchmark son:</p><ul><li>Java 11 (Imperative) — Spring boot 2.6</li><li>Java 11 (Reactive) — Spring webflux 5.3</li><li>Elixir 1.13- Cowboy 2.2</li><li>Go 1.18 — Gin 1.8.1</li></ul><p>Puedes revisar el código de cada una de las implementaciones en el siguiente <a href="https://github.com/maocq/backend-benchmark">link</a>, además podrás encontrar el detalle de cómo ejecutar las <a href="https://github.com/maocq/backend-benchmark/blob/master/RUN.md">pruebas</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*vabcHyEl_TY449cGG_KAGQ.png" /></figure><h3>Ambiente</h3><p>Para la ejecución de cada una de las pruebas generamos un entorno de forma aislada de la siguiente forma:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/553/1*mxjM4F176IkSTjKTXQQIHA.png" /></figure><p>En el gráfico anterior tenemos 4 cajas que representan instancias de EC2, cada una con una única responsabilidad.</p><p>La caja del medio es donde tendremos nuestro stack, el cual, como mencionamos anteriormente, se encuentra aislado para que los demás componentes no afecten sus resultados. Los demás componentes de la derecha corresponden, uno, a una base de datos Postgres, y el otro, a una instancia con Nodejs que representará nuestro servicio externo y que se encargará de simular latencias. Por último, una instancia encargada de realizar las pruebas de carga y recolectar los resultados.</p><h3>Escenarios</h3><h4>Health check</h4><p>El primer escenario que validaremos es un caso sencillo, donde el servicio solo nos retornará una cadena de texto. Normalmente podemos encontrar diferentes <em>benchmark</em> que validan dicho escenario, y aunque es un escenario importante no representa del todo los casos que nuestros stacks deben enfrentar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/549/1*uljhmqLWyHPZq_CxFw5KOA.png" /></figure><p>Las gráficas anteriores muestran el comportamiento de las transacciones por segundo (tps) soportadas por cada uno de los stacks durante 5 minutos de carga (Entre más alto mejor).</p><h4>Caso 1</h4><p>A partir de este momento intentaremos replicar casos un poco más cercanos a la realidad, en donde nuestro servicio no actúa solo sino que deberá interactuar con otros servicios.</p><p>Este escenario realizará un par de llamados a servicios externos (en nuestras implementaciones estos podrían equivaler a una validación de seguridad, un llamado a otra aplicación, una consulta de información, entre otros). Luego realizará una consulta a la base de datos para posteriormente realizar un último llamado a un servicio externo y finalizar actualizando su estado.</p><p>Lo anterior se puede resumir en el siguiente diagrama de secuencia:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/494/1*39iMcWik58M_u2dKhS_0vw.png" /></figure><p>Primero ejecutaremos nuestras pruebas en donde nuestro servicio externo simulará una latencia de 50 milisegundos en cada petición.</p><p>Luego ejecutaremos la misma prueba pero esta vez aumentando la latencia a 200 milisegundos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/553/1*t1HYqdnKDksdWzOJINBnsw.png" /><figcaption>Latencia de 50ms</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/553/1*xmqL3uzSTiwJ9u8eQzRNrg.png" /><figcaption>Latencia de 200ms</figcaption></figure><p>Un primer análisis de los resultados anteriores nos muestra que aunque la latencia aumenta casi 4 veces, las alternativas en los stacks no bloqueantes siguen comportándose de forma similar; diferente a la alternativa bloqueante (Java imperative) que se ve afectada en la misma proporción, pasando de tener un rendimiento de casi 200 tps a un poco menos de 50 tps.</p><p><strong>Nota:</strong> El driver de base de datos de Elixir ofrece una mayor optimización en la actualización de los datos (update), lo que le da una pequeña ventaja en el escenario anterior.</p><h4>Caso 2</h4><p>El siguiente caso representa un escenario un poco más sencillo que el anterior, el cual realizará una consulta de información en la base de datos y posteriormente un llamado a un servicio externo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*YOLVMZOgI7pzR0eR5CZM9A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/564/1*X00YCAQD2Sn_36-kebN7RA.png" /><figcaption>Latencia de 100ms</figcaption></figure><h4>Caso 1 + Caso 2</h4><p>A continuación realizaremos la ejecución de los casos 1 y 2 de forma simultánea.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*CSxXSs7GEnVNB0xyCqFGEg.png" /><figcaption>Latencia de 80ms</figcaption></figure><h4>Caso 3</h4><p>Durante el caso 3 solo realizaremos una consulta de información a la base de datos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/287/1*QIgDkTLnFDLu4saxZB-NEw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/555/1*vESL9WCIn5aBpyZ-tnEOdQ.png" /></figure><h4>Generación de números primos</h4><p>Con este escenario pretendemos simular servicios que realizan operaciones relacionadas netamente con tareas vinculadas a la CPU, cómo por ejemplo el cálculo de los 1.000 primeros números primos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/576/1*KoSiQMsLmmzMHqf7-r1t4g.png" /></figure><p>Dado que en Java reactivo (<em>webflux</em>) es fácil usar un grupo de subprocesos dedicado, podemos separar las tareas vinculadas a la CPU en un grupo de subprocesos con una cantidad fija igual al número de procesadores disponibles. Lo anterior nos genera un mejor rendimiento al evitar al máximo el <a href="https://en.wikipedia.org/wiki/Context_switch">context switch</a> (Almacenamiento del estado de un proceso, de modo que pueda restaurarse y reanudar la ejecución en un punto posterior).</p><h4>Solo servicio externo</h4><p>El escenario a continuación realizará el llamado un servicio externo que presenta una latencia de 80 milisegundos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/314/1*ITb6urKoUMnnaKzUfbL_WQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/571/1*1qm78neMhMSProhQGJ5KOw.png" /></figure><h4>Caso 1 + números primos</h4><p>Y, por último la ejecución en paralelo del caso 1 más la generación de números primos que nos permita ver si los recursos están siendo usados de forma óptima.</p><p>El siguiente escenario ejecutará el caso número 1 por cinco minutos y durante su ejecución se realizarán múltiples llamadas al servicio de números primos por un minuto (línea azul).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/597/1*3mOB1Q6YoTKe4jIyhps4kQ.png" /><figcaption>Latencia de 80ms</figcaption></figure><p>En las gráficas anteriores podemos observar cómo el stack bloqueante (Java imperativo) debido a que gran parte del tiempo se encuentra bloqueado esperando una respuesta, no es capaz de hacer un uso óptimo de sus recursos dejando estos inutilizados.</p><h3>Uso de recursos de memoria y cpu</h3><p>Durante la ejecución de los escenarios anteriores se activó el monitoreo de recursos en dichas instancias las cuales arrojaron los siguientes resultados.</p><p><em>Los siguientes valores fueron tomados en la muestra realizada con instancias t2.micro con el fin de validar el uso óptimo en ambientes con pocos recursos.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*F2Z0M5jv_3XuwDNrnYvTug.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/601/1*Dj43ejyjVEFzQxWD-QGV1g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/613/1*Y2NcsJUysixnuOmp0VDVFA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/585/1*_MljODSiz9be9MdlcPNXkQ.png" /></figure><p>Podemos resumir las gráficas anteriores en:</p><ul><li>El consumo de recursos en Java reactivo es en promedio de 600M de memoria y un uso promedio del 70% de la cpu.</li><li>El consumo en Java imperativo es en promedio de 550M de memoria y solo se puede ver un uso de la cpu en los escenarios de tareas vinculadas a cpu (últimos escenarios ejecutados) ya que en los demás los hilos se encuentran bloqueados la mayor parte del tiempo esperando una respuesta.</li><li>El consumo de recursos en Go es bastante estable con un uso medio de 350M de memoria y un uso máximo de 65% de cpu.</li><li>El consumo de recursos en Elixir es en promedio de 450M de memoria y un uso de la cpu llegando en algunos escenarios al 95%.</li></ul><blockquote>Es importante anotar nuevamente que los escenarios fueron ejecutados múltiples veces y en diferentes máquinas con el fin de garantizar que los datos presentados reflejaran un comportamiento real de cada uno de los stacks puestos a prueba.</blockquote><h3>Conclusiones</h3><ul><li>El uso de alternativas no bloqueantes nos permite hacer un uso más eficiente de los recursos.</li><li>En contextos de baja concurrencia y latencias internas muy bajas, podemos elegir fácilmente alternativas bloqueantes sin mayores inconvenientes. Por otro lado, si necesitamos soportar un mayor número de concurrencias la elección debe ser una alternativa no bloqueante.</li><li>Los stacks no bloqueantes muestran un comportamiento similar entre ellos.</li><li>En los stacks de Java el rendimiento al iniciar la prueba no es el más óptimo debido al calentamiento (<a href="https://tech.oyorooms.com/jvm-warmup-6dccee485dc4">warmup</a>) que debe ocurrir en la jvm. El anterior problema se pretende solucionar en proyectos como spring native.</li></ul><p>Por último, puedes revisar el resultado completo de las ejecuciones en el siguiente <a href="https://github.com/maocq/benchmark-results/tree/master/backend-benchmark">link</a> así como el <a href="https://github.com/maocq/backend-benchmark/blob/master/results/results.md">resultado </a>de las mismas pruebas ejecutadas en instancias con menos recursos (t2.micro) donde podrá observar un comportamiento similar. Además puede complementar el bechmark con otros escenarios en <a href="https://bancolombia.github.io/performance-benchmark-stacks/">https://bancolombia.github.io/performance-benchmark-stacks/</a></p><p>Gracias.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd1342e84152" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/benchmark-de-tecnolog%C3%ADas-backend-dd1342e84152">Benchmark de tecnologías Backend</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>
    </channel>
</rss>