Forem: Abelardo Ruben Irarrázabal Díaz

Clean Code - Funciones

Abelardo Ruben Irarrázabal Díaz — Fri, 15 Mar 2024 16:33:39 +0000

Funciones

Introducción:

La importancia de escribir funciones pequeñas, cohesivas y fáciles de entender. Las funciones bien diseñadas hacen que el código sea más legible, mantenible y reutilizable.

Principios Clave:

Pequeñas: Las funciones deben ser lo más pequeñas posible, idealmente con un máximo de 20-30 líneas de código.
Cohesivas: Las funciones deben realizar una única tarea bien definida.
Entradas y salidas: Las funciones deben tener un número limitado de entradas y salidas bien definidas.
Nombres significativos: Los nombres de las funciones deben indicar claramente la acción que realizan.
Sin efectos secundarios: Las funciones no deben modificar variables globales o el estado del sistema de forma inesperada.

Ejemplo de Funciones en C#:

Mala Práctica:

public void CalcularTotalCompra(Cliente cliente, List<Producto> productos) {

  // Calcular el total sin impuestos

  decimal totalSinImpuestos = 0;
  foreach (Producto producto in productos) {
    totalSinImpuestos += producto.Precio;
  }

  // Calcular el impuesto

  decimal impuesto = totalSinImpuestos * 0.15m;

  // Calcular el total

  decimal total = totalSinImpuestos + impuesto;

  // Mostrar el total

  Console.WriteLine("Total: " + total);

}

Beuna Práctica

public decimal CalcularTotalSinImpuestos(List<Producto> productos) {

  decimal total = 0;
  foreach (Producto producto in productos) {
    total += producto.Precio;
  }

  return total;

}

public decimal CalcularImpuesto(decimal totalSinImpuestos) {
  return totalSinImpuestos * 0.15m;
}

public void MostrarTotal(Cliente cliente, decimal total) {
  Console.WriteLine("Cliente: " + cliente.Nombre);
  Console.WriteLine("Total: " + total);
}

public void CalcularTotalCompra(Cliente cliente, List<Producto> productos) {

  decimal totalSinImpuestos = CalcularTotalSinImpuestos(productos);
  decimal impuesto = CalcularImpuesto(totalSinImpuestos);
  decimal total = totalSinImpuestos + impuesto;

  MostrarTotal(cliente, total);

}

En la buena práctica:

Se han dividido las responsabilidades en funciones más pequeñas y cohesivas.
Las funciones tienen nombres significativos que indican la acción que realizan.
Las funciones no tienen efectos secundarios.

En la mala práctica:

La función CalcularTotalCompra es demasiado grande y compleja.
La función realiza varias tareas diferentes, lo que la hace difícil de entender y mantener.
La función modifica variables globales, lo que puede generar errores inesperados.
Al escribir funciones pequeñas y cohesivas, el código se vuelve más legible, mantenible y reutilizable.

Conclusión

Escribir funciones pequeñas, cohesivas y con nombres significativos es una práctica fundamental para escribir código limpio. Al seguir los principios y consejos mencionados, puedes mejorar la legibilidad, la mantenibilidad y la reutilizabilidad de tu código.

Clean Code - Nombres significativos

Abelardo Ruben Irarrázabal Díaz — Fri, 15 Mar 2024 15:45:50 +0000

Nombres Significativos

Introducción:

El capítulo 2 de "Clean Code" de Robert C. Martin se centra en la importancia de elegir nombres significativos para variables, funciones, clases y otros elementos del código. Los nombres significativos ayudan a comprender el código a simple vista, lo que facilita su mantenimiento y colaboración.

Principios Clave:

Evitar nombres genéricos: No usar nombres como x, y, z, a1, b2, etc., ya que no dan información sobre el propósito del elemento.
Utilizar nombres descriptivos: Elegir nombres que describan claramente lo que representa el elemento. Por ejemplo, nombreCliente es mejor que nombre.
Utilizar verbos para las funciones: Los nombres de las funciones deben indicar la acción que se realiza. Por ejemplo, calcularAreaTriangulo es mejor - que areaTriangulo.
Utilizar sustantivos para las variables: Los nombres de las variables deben indicar el tipo de dato que almacenan. Por ejemplo, edadCliente es mejor que edad.
Considerar el contexto: El nombre debe tener sentido en el contexto del código en el que se utiliza.

Ejemplo en C#:

Mala práctica:

public class MiClase { // Nombre genérico, no indica el propósito de la clase

  public void Calcular() { // Nombre genérico, no indica qué se calcula
    int num; // Nombre genérico, no indica qué tipo de dato almacena ni su propósito
    num = 10; // Asignación sin contexto
    if (num > 5) { // Condición sin contexto
      // ...
    }
  }
}

Buena Práctica

public class CalculadoraPrecioTotal { // Nombre descriptivo, indica el propósito de la clase

  public void CalcularPrecioTotal(Producto producto, int cantidad) { // Nombre descriptivo, indica la acción que realiza la función y sus parámetros

    decimal precioTotal = producto.Precio * cantidad; // Asignación con contexto
    if (precioTotal > 100) { // Condición con contexto
      // ...
    }
  }
}

Conclusión:

Elegir nombres significativos es una práctica fundamental para escribir código limpio. Al seguir los principios y consejos mencionados, puedes mejorar la legibilidad, la mantenibilidad y la colaboración de tu código.

¿Qué es el código limpio?

Abelardo Ruben Irarrázabal Díaz — Fri, 15 Mar 2024 15:41:56 +0000

Clean code o código limpio se refiere a código que es fácil de leer, entender, mantener y modificar. Es código que está escrito de una manera clara, concisa y expresiva, siguiendo un conjunto de buenas prácticas y convenciones.

Beneficios del código limpio:

Mejora la legibilidad: El código limpio es fácil de leer y comprender, lo que facilita su mantenimiento y actualización.
Reduce errores: Un código bien escrito tiene menos errores, lo que reduce el tiempo dedicado a la depuración.
Aumenta la productividad: Los desarrolladores pueden trabajar de manera más eficiente con código limpio, ya que no tienen que perder tiempo descifrando código complejo.
Mejora la colaboración: El código limpio facilita la colaboración entre desarrolladores, ya que todos pueden entenderlo fácilmente.

Principios del código limpio

Si quiere profundizar en cada uno de los principios del clean code creare una serie de posts con su respectivo detalle

PowerShell - Como obtener información desde Internet information services

Abelardo Ruben Irarrázabal Díaz — Fri, 15 Mar 2024 13:24:09 +0000

Este script de PowerShell es una herramienta valiosa para un ingeniero que necesita obtener información sobre los sitios web y las aplicaciones web alojados en un servidor IIS (Internet Information Services).

Obtenemos de forma rapida toda la información que se puede necesitar y generar un descubrimiento de las aplicaciones o sitios existente. Aquí está la explicación del código desde esa perspectiva:

Script Powershell

El siguiente escript ademas de obtener la información la exporta a un archivo txt separados por pipe "|":

    Write-Host "Inicio - Script"
    $Websites = Get-Website
    $Hostname = hostname
    $filename = "apps-"+$Hostname+".txt"

    'Hostname|Type|Site|Webapp_Name|State|PhysicalPath|Bindings|AppPool_Name|AppPool_State|AppPool_ManagedRuntimeVersion' > $filename

    foreach ($Website in $Websites) {

        $AppPool = Get-IISAppPool -Name $Website.ApplicationPool

        $customWeb = [PSCustomObject]@{
            Hostname = $Hostname
            Type = 'Site'
            Site = $Website.Name -join ';'
            Webapp_Name = ''
            State                 = $Website.State -join ';'
            PhysicalPath          = $Website.PhysicalPath
            Bindings              = $Website.Bindings.Collection -join ';'
            AppPool_Name                  = $AppPool.Name -join';'
            AppPool_State                 = $AppPool.State -join ';'
            AppPool_ManagedRuntimeVersion = $AppPool.ManagedRuntimeVersion -join ';'

        }

        $customWeb.Hostname + '|' +$customWeb.Type + '|' + $customWeb.Site + '|' + $customWeb.Webapp_Name + '|' + $customWeb.State + '|' + $customWeb.PhysicalPath + '|' + $customWeb.Bindings + '|' + $customWeb.AppPool_Name + '|' + $customWeb.AppPool_State + '|' + $customWeb.AppPool_ManagedRuntimeVersion >> $filename
    }

    $Webapps = Get-WebApplication

    foreach ($Webapp in $Webapps) {
        $name = ($Webapp.Path).Replace('/','')
        $site = $Webapp.GetParentElement().Attributes['name'].Value
        $AppPool = Get-IISAppPool -Name $Webapp.ApplicationPool

        $customApp = [PSCustomObject]@{
            Hostname = $Hostname
            Type = 'Application'
            Site = $site
            Webapp_Name  = $name
            State = ''
            PhysicalPath = $Webapp.PhysicalPath
            Bindings = ''
            AppPool_Name                  = $AppPool.Name -join';'
            AppPool_State                 = $AppPool.State -join ';'
            AppPool_ManagedRuntimeVersion = $AppPool.ManagedRuntimeVersion -join ';'
        }

        $customApp.Hostname + '|' +$customApp.Type + '|' + $customApp.Site + '|' + $customApp.Webapp_Name + '|' + $customApp.State + '|' + $customApp.PhysicalPath + '|' + $customApp.Bindings + '|' + $customApp.AppPool_Name + '|' + $customApp.AppPool_State + '|' + $customApp.AppPool_ManagedRuntimeVersion >> $filename
    }  
    Write-Host $filename
    Write-Host "Fin - Script"

Explicación de Script

Write-Host "Inicio - Script": Este comando indica el inicio del script, lo cual es útil para el seguimiento de la ejecución del script.
$Websites = Get-Website: Este comando recopila todos los sitios web alojados en el servidor IIS. Esta información es crucial para entender qué sitios están actualmente en funcionamiento.
$Hostname = hostname: Este comando recupera el nombre del servidor, lo cual es útil para la documentación y el seguimiento.
$filename = "apps-"+$Hostname+".txt": Este comando genera un nombre de archivo basado en el nombre del servidor. Este archivo se utilizará para almacenar la información recopilada. 5. 'Hostname|Type|Site|Webapp_Name|State|PhysicalPath|Bindings|AppPool_Name|AppPool_State|AppPool_ManagedRuntimeVersion' > $filename : Este comando crea un archivo y escribe en él la cabecera de la tabla. Este archivo servirá como un registro detallado de los sitios y aplicaciones web en el servidor.
foreach ($Website in $Websites) {...}: Este bucle recorre cada sitio web recopilado anteriormente, recopila información detallada sobre cada uno, incluyendo su estado, ruta física, enlaces, y detalles del pool de aplicaciones, y luego escribe esta información en el archivo.
$Webapps = Get-WebApplication: Este comando recopila todas las aplicaciones web alojadas en el servidor IIS.
foreach ($Webapp in $Webapps) {...}: Este bucle recorre cada aplicación web recopilada anteriormente, recopila información detallada sobre cada una, incluyendo su estado, ruta física, y detalles del pool de aplicaciones, y luego escribe esta información en el archivo.
Write-Host $filename: Este comando imprime el nombre del archivo en la consola. Esto es útil para saber dónde se ha guardado la información recopilada.
Write-Host "Fin - Script": Este comando indica el final del script, lo cual es útil para el seguimiento de la ejecución del script.

Consideraciones

El script solo fue probado en las siguientes versiones de sistema operativo: Windows Server 2016 , Windows Server 2019 y Windows 10

Conclusión

En conclusión, este script de PowerShell es una herramienta esencial para cualquier ingeniero que necesite recopilar información detallada sobre los sitios web y las aplicaciones web alojados en un servidor IIS. Proporciona una visión general rápida y eficiente del entorno de IIS, recopilando datos como el estado del sitio, la ruta física, los enlaces y los detalles del pool de aplicaciones. Además, almacena esta información en un archivo de texto para su posterior análisis y seguimiento. Este script es un excelente ejemplo de cómo se pueden utilizar las capacidades de automatización de PowerShell para simplificar y acelerar las tareas de administración del sistema.

Utilizando HttpClient con IHttpClientFactory en .Net 6

Abelardo Ruben Irarrázabal Díaz — Fri, 21 Oct 2022 15:46:32 +0000

Para los que están entrando o ya llevamos un tiempo en el mundo de .Net y necesitan consumir una api rest, es muy común que hayan utilizado HttpClient para realizarlo. Hay otras librerías como RestSharp que también permiten consumir servicios, pero RestSharp sigue utilizando HttpClient.

Uno de los grandes problemas que nos podemos encontrar al implementar HttpClient es la mala implementación, volviendo nuestra aplicación inestable, como en el siguiente código:



using(var client = new HttpClient())
{
    //Realizamos solicitudes HTTP
}

En este post no profundizaremos en los errores que pueden ocasionarse con una mala implementación, nos centraremos en como realizar una implementación mas limpia y estable con IHttpClientFactory.

Definición de IHttpClientFactory

La documentación de Microsoft nos define lo siguiente:

Se trata de una interfaz que se usa para configurar y crear HttpClient instancias en una aplicación mediante inserción de dependencias (DI). También proporciona extensiones para el middleware basado en Polly a fin de aprovechar los controladores de delegación en HttpClient.

Lo que quiere decir que a través de esta interfaz generaremos instancias que podremos inyectar en nuestro servicio o clase en donde utilizaremos IHttpClientFactory asegurando una mayor estabilidad y de forma centralizada.

Tambien nos menciona Polly, que en resumen es una librería que nos permite realizar reintentos de request cuando el codigo http de un response coincida con algún codigo que le indiquemos. Es mucho mas sencilla su implementación con IHttpClientFactory, pero la política de reintentos ya es material para otro post.

Implementemos la interfaz

Ahora que ya sabemos el concepto básico de IHttpClientFactory, procedamos a implementarlo en el código

Prerequisitos

Visual Studio 2022

1. Creando el proyecto

Lo primero es crear un proyecto con la plantilla de tipo ASP .NET Core Web API
El nombre no es relevante pero para esta ocasión será HttpClientApi
Seleccionamos el framework .NET 6.0 y habilitamos compatibilidad con OpenAPI (swagger)

2. Estructura del proyecto

La estructura del proyecto quedar según la siguiente imagen, creando carpetas por cada capa de nuestra aplicación. Esto es solo para efecto de ejemplo, ya que en vez de carpetas podríamos generar librerías de clases por cada capa.

3. Implementemos IHttpClientFactory

Ya tenemos lista nuestra estructura !!!
Ahora vamos al código

Clases de la capa Models



namespace HttpClientApi.Models;

public class Bird
{
    public string Uid { get; set; }
    public Name Name { get; set; }
    public Images Images { get; set; }
    public Links _Links { get; set; }
    public int Sort { get; set; }
}



namespace HttpClientApi.Models;

public class Images
{
    public string Main { get; set; }
    public string Full { get; set; }
    public string Thumb { get; set; }
}



namespace HttpClientApi.Models;

public class Links
{
    public string Self { get; set; }
    public string Parent { get; set; }
}



namespace HttpClientApi.Models
{
    public class Name
    {
        public string Spanish { get; set; }
        public string English { get; set; }
        public string Latin { get; set; }
    }
}

Ahora debemos modificar el appsettings.json para dejar la url que consumiremos con nuestro HttpClient:

appsettings.json:



{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Endpoint": {
    "UrlBirds": "https://aves.ninjas.cl/api/birds"
  }
}

Agregamos la propiedad Endpoint:UrlBirds donde se encuentra la url.

Para implementar IHttpClientFactory modificaremos el archivo Program.cs

Program.cs:



using HttpClientApi.Services;

var builder = WebApplication.CreateBuilder(args);

var configuration = builder.Configuration;
builder.Services.AddControllers();

builder.Services.AddHttpClient<IBirdsService, BirdsService>(client =>
{
    client.BaseAddress = new Uri(configuration.GetValue<string>("Endpoint:UrlBirds"));
    client.Timeout = TimeSpan.FromSeconds(20);
    client.DefaultRequestHeaders.Add("HEADER_API_KEY", "claveficticia");
});
// Add services to the container.

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

En el codigo primero traemos la configuración que permitirá traer la url desde appsettings.json



var configuration = builder.Configuration;

En el siguiente bloque implementamos IHttpClientFactory



builder.Services.AddHttpClient<IBirdsService, BirdsService>(client =>
{
    client.BaseAddress = new Uri(configuration.GetValue<string>("Endpoint:UrlBirds"));
    client.Timeout = TimeSpan.FromSeconds(20);
    client.DefaultRequestHeaders.Add("HEADER_API_KEY", "claveficticia");
});

Con el metodo AddHttpClient le indicamos la interfaz y la clase donde inyectaremos el HttpClient.
Luego vamos a asignar tres propiedades BaseAddress, Tiemout, DefaultRequestHeaders
- BaseAddress: asignamos la url.
- Timeout: asignamos el máximo tiempo de respuesta de una solicitud.
- DefaultRequestHeaders: Agregamos una cabecera extra a nuestro Request, que para efectos prácticos puede ser una api key.

Llamando al servicio:

Tenemos una interfaz y una clase en la carpeta Services

IBirdsService:



using HttpClientApi.Models;

namespace HttpClientApi.Services
{
    public interface IBirdsService
    {
        Task<List<Bird>> Get();
    }
}

La interfaz con el metodo Get nos permitirá implementar la inyección de dependencia.

BirdsService:



using HttpClientApi.Models;

namespace HttpClientApi.Services
{
    public class BirdsService : IBirdsService
    {
        private readonly HttpClient _httpClient;

        public BirdsService(HttpClient httpClient) => (_httpClient) = (httpClient);

        public async Task<List<Bird>> Get()
        {
            var listBirds = await _httpClient.GetFromJsonAsync<List<Bird>>(_httpClient.BaseAddress);

            return listBirds;
        }
    }

La clase BirdsService implementa la interfaz IBirdsService.
En el constructor declaramos HttpClient httpClient para que pueda ser inyectado desde el Program.cs como lo vimos en el codigo de mas arriba.

Listo ya tenemos el servicio conectado solo nos falta llamarlo desde el controlador BirdsController



using HttpClientApi.Services;
using Microsoft.AspNetCore.Mvc;

namespace HttpClientApi.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class BirdsController : ControllerBase
    {
        private readonly IBirdsService _birdsService;

        public BirdsController(IBirdsService birdsService) => _birdsService = birdsService;

        [HttpGet]
        public async Task<IActionResult> Get()
        {
            return Ok(await _birdsService.Get());
        }
    }
}

Y listo ahora ya estamos en condiciones de realizar el get Birds

Conclusiones

Como vimos en el ejemplo y por la experiencia que tengo utilizándolo es mucho mas limpio con AddHttpCLient. Por que como vimos en la clase BirdsService en ningún momento declaramos la url, el timeout o si fuera necesario alguna cabecera adicional.
Le damos la responsabilidad a la inyección de dependencia que lo haga.
Para agregar IHttpClientFactory en este ejemplo lo hicimos directo en el Program.cs pero si quisieras dejar este archivo mas limpio podemos alojar esta configuración en otro archivo .cs, con la implementación ya lista como un metodo estático y solo la llamamos desde Program.cs. Esto es una buena opción cuando necesitas inyectar distintos servicios, es ahi donde nuestro código se nos puede extender.
Administra la agrupación y la duración de las instancias de HttpClientMessageHandler subyacentes. La administración automática evita los problemas comunes de DNS (Sistema de nombres de dominio) que se producen al administrar la duración de HttpClient de forma manual. Esto quiere decir que los problemas que indicamos al principio de este post, que nos provocaba trabajar con HttpClient de forma manual del riesgo de solicitudes que queden abiertas y colapso de los sockets, ya no existirían.

Mejorar el rendimiento de mis aplicaciones .Net 6 con REDIS

Abelardo Ruben Irarrázabal Díaz — Fri, 14 Oct 2022 16:24:46 +0000

En este post nos centraremos en el caso de uso de caching para la optimización de la respuesta de algún servicio en especifico.

Para ello explicare el siguiente codigo que esta en mi repositorio de github CacheServicesApp donde esta implementado en una API .Net 6 con redis

Pre requisitos

Lo primero es tener instalado redis, para ello tengo un post en el cual explico como montar redis en docker Redis en Docker Container
Tener instalado Visual studio 2022

El problema

El siguiente problema es hipotético el cual puede pasar en un ambiente productivo real:

Tenemos una api que esta montada en la nube en EE.UU la cual debe comunicarse con otro servicio externo el cual esta en Chile. El problema es que tiene un latencia muy alta debido a la diferencia geográfica entre ambos servicios y la alta demanda de solicitudes lo que afecta aumentando el tiempo de respuesta.

Solución

Una posible solución es montar un servidor de cache distribuida (en este caso Redis) que este en la misma localización que este nuestro servicio.

Por que cache distribuida y no en la cache de la memoria: Esto dependerá si los datos que necesitamos extraer también lo consume otro cliente en ese caso seria una buena opción utilizar cache distribuida.

Construyendo el servicio

En esta ocasión consumiremos un endpoint desde nuestro nuevo servicio construido Net Core 6, el cual en una primera petición obtendrá los datos, los almacenara en Redis y los devuelve al front. En una segunda petición traera los datos directo de Redis optimizando los tiempos de respuesta.

Crear la solución

En Visual Studio 2022 creamos un proyecto con la plantilla ASP NET. Core Web API.
Luego nos solicitará el nombre del proyecto el cual sera CacheServiceApp
En el siguiente paso seleccionamos
- Framework: .NET 6.0
- Marcar check de Configurar para HTTPS
- Marcar check de Usar Controladores
- Marcar check de Habilitar compatibilidad con OpenAPI (para implementar swagger)
Con esto pasos ya tenemos nuestro proyecto y solución lista

Crear los proyectos

ahora debemos agregar dos capas al proyecto, las cuales serán del tipo librería de clases y quedaría según la siguiente imagen:

Ahora tenemos: la capa Model de nuestras entidades, la capa Services para conectarnos a fuentes externas y nuestra capa de presentación que para esta ocasión es de tipo API.

Instalar los paquetes nugget

Para conectarnos a Redis debemos instalar los siguientes paquetes

En nuestra capa CacheServiceApp.Services instalamos el paquete

Microsoft.Extensions.Caching.Abstractions

Este paquete es el que a través de la interfaz IDistributedCache nos permitirá interactuar con Redis que lo veremos mas adelante.

En la capa donde exponemos la api CacheServiceApp instalamos el paquete:

Microsoft.Extensions.Caching.StackExchange

Esto nos permitirá en el archivo Program.cs inyectar la cadena de conexión a Redis.

Conectar al servicio

CacheServiceApp

Lo primero como mencionaba en el punto anterior debemos generar la conexión en la capa de presentación CacheServiceApp (API) en el archivo Program.cs y dejaremos el string de conexión en el archivo appsettings.json.

appsettings.json:



{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Caching": {
    "RedisConnection": "localhost:6379"
  },
  "Endpoint": {
    "UrlBirds": "https://aves.ninjas.cl/api/birds"
  }
}

RedisConnection es nuestra cadena de conexión a redis. Recuerden que en este ejemplo utilizamos redis en docker, que el tutorial lo deje en el link mas arriba.
La propiedad Endpoint es la url del servicio que consumiremos para simular la latencia entre nuestra api y el servicio y luego almacenaremos esos datos en Redis.

Program.cs:



using CacheServiceApp.Services;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
var configuration = builder.Configuration;
builder.Services.AddControllers();

builder.Services.AddHttpClient<IBirdsService, BirdsService>(client =>
{
    client.BaseAddress = new Uri(configuration.GetValue<string>("Endpoint:UrlBirds"));
});

builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = configuration.GetValue<string>("Caching:RedisConnection");
});

// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseAuthorization();

app.MapControllers();

app.Run();

Aca son importantes tres puntos en la clase:

obtengo la configuración para traer el string de conexión del appsettings.json



var configuration = builder.Configuration;

Genero la inyección del HttpClient del servicio que consumimos



builder.Services.AddHttpClient<IBirdsService, BirdsService>(client =>
{
    client.BaseAddress = new Uri(configuration.GetValue<string>("Endpoint:UrlBirds"));
});

Conexión a Redis



builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = configuration.GetValue<string>("Caching:RedisConnection");
});

CacheServiceApp.Services

Para conectarnos al servicio se debe crear la clase BirdService y la interfaz IBirdService para luego realizar la inyección de dependencia.

BirdService.cs:



public class BirdsService : IBirdsService
{
    private readonly HttpClient _httpClient;
    private readonly IDistributedCache _cache;

    public BirdsService(HttpClient httpClient, IDistributedCache cache) => (_httpClient, _cache) = (httpClient, cache);

    public async Task<List<Bird>> Get()
    {
        string cacheKey = "listBirds";
        string serializedBirds;

        var redisBirds = await _cache.GetAsync(cacheKey);
        List<Bird> listBirds;

        if (redisBirds != null)
        {
            serializedBirds = Encoding.UTF8.GetString(redisBirds);
            listBirds = JsonConvert.DeserializeObject<List<Bird>>(serializedBirds);
        }
        else
        {
            listBirds = await _httpClient.GetFromJsonAsync<List<Bird>>(_httpClient.BaseAddress);
            serializedBirds = JsonConvert.SerializeObject(listBirds);
            redisBirds = Encoding.UTF8.GetBytes(serializedBirds);
            var options = new DistributedCacheEntryOptions()
                .SetAbsoluteExpiration(TimeSpan.FromSeconds(30))
                .SetSlidingExpiration(TimeSpan.FromSeconds(10));

            await _cache.SetAsync(cacheKey, redisBirds, options);
        }

        return listBirds;
    }
}

Aca son importantes 3 puntos en la clase:

Declarar en el contructor la interfaz IDistributedCache para obtener y gurdar datos en Redis



private readonly HttpClient _httpClient;
private readonly IDistributedCache _cache;

public BirdsService(HttpClient httpClient, IDistributedCache cache)

Obtener datos desde redis



var redisBirds = await _cache.GetAsync(cacheKey);

Guardar datos en Redis



var options = new DistributedCacheEntryOptions()
                .SetAbsoluteExpiration(TimeSpan.FromSeconds(30))
                .SetSlidingExpiration(TimeSpan.FromSeconds(10));

await _cache.SetAsync(cacheKey, redisBirds, options);

Ya con la implementación en la clase BirdService.cs estaríamos haciendo lo siguiente:

Verificamos si existen datos en redis con la key listBirds
Si hay datos los deserializa de arregglo de bytes y posteriormente de json a objeto
Si no hay datos en la cache la primera vez consulta el servicio de Birds
Serializa en json y luego los guardamos como arreglo de bytes en redis con un expiración absoluta de 30 segundos y la expiración parcial 10 segundos, lo que quire decir que si nadie consulta en 10 segundos expira con un máximo de 30 segundos.

Probemos la solución

Corremos nuestra aplicación CacheServiceApp y nos mostrara el swagger.

Para probarla utilizare Postman que para mi caso la api utiliza el puerto 5112:

La primera vez que ejecutamos el servicio demora 9.73 segundos

La segunda vez que lo ejecutamos lo ira a buscar a Redis por lo que tendrá una mayor velocidad de respuesta bajando a 18 milisegundos.

Conclusiones

Para este ejemplo entre 9 segundos y 18 milisegundos no hay tanta diferencia, pero si lo implementan en un ambiente productivo en servicio que aprox se demora 10 y 30 segundos y tiene cientos de solicitudes por minuto, ahí si se vera la diferencia.
Cada vez que necesitamos mejorar el rendimiento debes evaluar si es necesario utilizar la cache distribuida o solo en la memoria RAM en donde esta montando el servicio.

💼 Mi Portafolio

Redis en Docker Container

Abelardo Ruben Irarrázabal Díaz — Wed, 21 Sep 2022 04:01:53 +0000

¿Que es Redis?

Base de datos NoSQL. No maneja el concepto de documentos como en mongo db o tablas como en postgres o mysql. Trabaja exclusivamente con pares key value y podemos almacenar múltiples pares clave valor. Redis almacena los datos 100% en memoria y no en disco, Permite que tenga una alta performance y la velocidad de acceso a la información sea mucho mayor. La desventaja es que al estar en memoria, su data es volátil. Igualmente tiene un sistema de guardado en disco para data persistente aunque su objetivo principal es guardar la data en cache.

Casos de uso principales

Real-time data store

Representa la oportunidad ideal para construir aplicaciones en tiempo real y que requieran baja latencia y alto rendimiento

Streaming & Messaging

Redis desde su versión 5 ofrece un tipo de dato particular llamado stream que lo hace ideal para aplicaciones del estilo y se usa para colas de mensajería

Caching & Session Storage

Puede funcionar como sistema de cache para optimizar al máximo el acceso a datos y la performance en general en aplicaciones

Instalar y correr el contenedor de redis

Pre requisitos

Previo a irnos a la practica debemos considerar lo siguiente:

Debes tener instalado Docker desktop Link oficial

Instalar contenedor

Debemos ejecutar el siguiente comando

docker run --name my-redis -p 6379:6379 -d redis

creamos y corremos el contenedor con el nombre my-redis
ruteamos el puerto 6379 de nuestra computadora con el puerto por defecto de redis en el contenedor con el 6379

Confirmamos que el contenedor este corriendo

docker ps

Para conectarnos a nuestro redis dentro de consola del contenedor

docker exec -it my-redis sh

Como conectarse desde mi equipo como cliente

Para mayor información sobre como conectarse con redis cli lo pueden revisar en la documentación oficial del siguiente link: get redis cli without installing redis server

Debes tener instalado nodejs y ejecutar el siguiente comando

npm i -g redis-cli

conectarse a un servidor redis remoto que en este caso seria nuestro redis container

rdcli -h localhost -p 6379

listo ya estamos conectados a nuestro contenedor con redis

💼 Mi Portafolio

Containers en .Net Core y Docker

Abelardo Ruben Irarrázabal Díaz — Wed, 17 Aug 2022 22:26:00 +0000

Actualmente existe mas de una forma para desplegar nuestras aplicaciones. Una de ellas es trabajar con contenedores, lo que nos permite construir, compartir y correr tus aplicaciones.
A continuación contenerizaremos una aplicación .Net Core 6 con docker, explicando paso a paso su configuración.

¿ Qué es un contenedor ?
¿ Qué es docker ?
Pre requisitos
Creando nuestra API Net Core 6
Creando el Dockerfile
Construir imagen y contenedor

¿ Qué es un contenedor ?

Es un paquete de software que agrupa el código de una aplicación junto con las bibliotecas y los archivos de configuración pertinentes, así como las dependencias necesarias para que la aplicación funcione.

¿ Qué es docker ?

Docker es una tecnología que le permite implementar aplicaciones como contenedores portátiles autónomos que pueden ejecutarse en la nube o en ambiente local, Linux o Windows.

Al igual que Docker, existen otros tipos de creadores de contenedores. En los últimos años, Docker se ha convertido en el formato de contenedor predeterminado.

Pre requisitos

Previo a irnos a la practica debemos considerar lo siguiente:

El ejemplo se realizara en un entorno windows 10
Debes tener instalado Docker desktop Link oficial
Tener instalado Visual Studio 2022 para crear la api en .Net 6

Creando nuestra API Net Core 6

En visual studio 2022 crearemos un proyecto con una plantilla tipo ASP.NET Core Web API:

Configuramos el proyecto con el nombre NetCoreDocker:

Seleccionamos el framework .NET 6.0,con las opciónes deshabilitadas Configurar HTTPS, Habilitar Docker, Do not use top-level statements. Las opciones que debemos tener habilitadas son Desactivar para usar api minimas, Habilitar compatibilidad con OPEN API (Swagger). El motivo de no habilitar docker es por que en el siguiente paso de forma manual crearemos nuestro Dockerfile:

Una vez creado nuestro proyecto debemos correr nuestra api y verificar que se visualice swagger con el endpoint por defecto WeatherForecast.

Creando el Dockerfile

Dockerfile es un archivo de texto que contine los pasos sobre cómo compilar una imagen docker.

El siguiente archivo que crearemos estara compuesto por tres partes:

Declaración de la imagen base a utilizar
La contrucción de nuestra app
Compilacion y creación del contenedor

Se crearan dos archivos, Dockerfile y .dockerignore los cuales deben quedar como el siguiente arbol de archivos.

NetcoreDocker
- NetcoreDocker
  - Dockerfile
  - .dockerignore
NetCoreDocker.sln

En el archivo Dockerfile debemos escribir lo siguiente

Dockerfile :



# Imagen base en la cual basaremos nuestra imagen
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /app

# Exponemos el puerto 80 
EXPOSE 80

# Copiar csproj y restauramos nuestra app
COPY ./*.csproj ./
RUN dotnet restore

# Copiamos todos los archivos y compilamos o contruimos nuestra app
COPY . .
RUN dotnet publish -c Release -o publish

# Construimos o instanciamos nuestro contenedor
FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build /app/publish .
    #Indicamos el archivo dll compilado (nombre del proyecto)
ENTRYPOINT ["dotnet", "NetCoreDocker.dll"]

Archivo .dockerignore es donde le indicamos las carpetas para omitir en la construcción de nuestra app para hacer que nuestro contexto de compilación sea lo más pequeño posible. En net core son las carpetas bin y obj

.dockerignore :



bin/
obj/

Construir imagen y contenedor

Ya estamos en condiciones de crear nuestra imagen, para ello debemos abrir una consola que para este ejemplo sera powershell. Puedes utilizar la cmd de windows o la que mas te acomode.

Comprobamos que tengamos docker instalado con:



docker --version

Nos posicionamos en la carpeta del proyecto:



cd C:\DevTest\NetCoreDocker\NetCoreDocker\

Construiremos nuestra imagen con el siguiente comando



docker build -t netcoreimage .

netcoreimage es el nombre de la imagen que le asignaremos

Luego debemos comprobar que este creada con el siguiente comando



docker images

Deberia devolvernos un resultados similar a:

Una vez creada la imagen ya podemos correr el contenedor con el siguiente comando:



docker run -d -p 5000:80 -e ASPNETCORE_ENVIRONMENT=Development --name apinetcore  netcoreimage

Explicación del script

-p 5000:80 indicamos el puerto del sistema operativo anfitrion que es el que permitira conectarnos a la api y el puerto del contenedor
-e ASPNETCORE_ENVIRONMENT=Development variable de entorno
--name apinetcore el nombre que le daremos al contenedor
netcoreimage es el nombre de la imagen en la cual se basara nuestro contenedor

Comprobamos que el contenedor esta corriendo:



docker ps

¡Listo! nuestra api ya esta contenerizada.

¿Como lo comprobamos?

Copiemos la siguiente url en nuestro navegador y lograremos visualizar swagger

http://localhost:5000/swagger/index.html

y si necesitamos probar el endpoint copiamos y pegamos en nuestro navegador la siguiente url

http://localhost:5000/WeatherForecast

💼 Mi Portafolio

Conectando API en .Net 5 con firebase storage

Abelardo Ruben Irarrázabal Díaz — Thu, 04 Aug 2022 18:06:00 +0000

Actualmente tenemos una variedad de alternativas para guardar documentos o imagenes, sobre todo de opciones en la nube. Una de las alternativas puede ser firebase storage que nos permite conectarnos desde cualquier app indpeendiente el lenguaje. En esta ocasión integraremos una Api en .Net 5 con firebase storage.

Este post esta divididos en tres partes:

Creación de proyecto en firebase
Crear un usuario en firebase
Integración de Api en .Net 5

Creación de proyecto en firebase

Primero debemos contar con una cuenta de google.
Luego debemos ingresar a la consola de firebase

Creamos un nuevo poyecto

Paso 1: Nombre del proyecto

Paso 2: desactivamos google analitycs para el proyecto

Una vez creado el proyecto seleccionamos storage del menu

Iniciamos en modo producción y seleccionamos ubicación

En la sección reglas (rules) copiamos y pegamos el siguiente código



rules_version = '2';
service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read, write: if request.auth != null;
    }
  }
}

Crear un usuario en firebase

Para poder acceder a firebase storage debemos crear un usuario en la sección Authentication y le damos a comenzar

Seleccionamos el metodo de autenticación por correo electrónico

En la pestaña users agregamos un nuevo usuario

Integración de Api en .Net 5

Ya realizados los pasos anteriores, estamos listos para conectar nuestra api .Net 5 a firebase. Para ello utilizaremos el código del siguiente repositorio:
Net Core Firebase Storage

El proyecto se divide en tres capas

FirebaseStorageApp
FirebaseStorageApp.Model
FirebaseStorageApp.Services

FirebaseStorageApp

Es nuestra api donde exponemos el endpoint para cargar documentos:



[HttpPost]
public async Task<IActionResult> Post([FromBody] FileModel file)
{
    string fileUrlFirebase = await Upload(file);
    return Ok(new { fileUrlFirebase });
}

private static async Task<string> Upload(FileModel file)
{
    var fileFromBase64ToStream = FirebaseStorageService.ConvertBase64ToStream(file.FileBase64);
    var fileStream = fileFromBase64ToStream.ReadAsStream();

    string fileUrlFirebase = await FirebaseStorageService.UploadFile(fileStream, file);
    return fileUrlFirebase;
}

Para este ejemplo utilizaremos variables de entorno con las keys necesarias para conectarse a firebase. Estas variables debemos reemplazarlas en el archivo Properties/launchSettings.json:



"IIS Express": {
    "commandName": "IISExpress",
    "launchBrowser": true,
    "launchUrl": "swagger",
    "environmentVariables": {
    "ASPNETCORE_ENVIRONMENT": "Development",
    "API_KEY_STORAGE": "Your api key storage",
    "AUTH_EMAIL": "your email authentication ",
    "AUTH_PASWORD": "your password autenticaction",
    "BUCKET_STORAGE": "your bucket name"
    }
}

AUTH_EMAIL y AUTH_PASWORD: debemos ingresar las configuradas en el paso 2 de este post.

API_KEY_STORAGE: en firebase la obtenemos en Configuración del proyecto < General:

BUCKET_STORAGE: en firebase la obtenemos en storage omitiendo gs://:

FirebaseStorageApp.Model

En esta capa tenemos la clase con los datos que solicitaremos para guardar documentos. Esta sera utilizada en el controlador y la capa de servicio.



public class FileModel
{
    [Required(ErrorMessage = "This field is required")]
    [MinLength(5, ErrorMessage = "5 characters is required")]
    public string FileBase64 { get; set; }

    [Required(ErrorMessage = "This field is required")]
    [MinLength(5, ErrorMessage = "5 characters is required")]
    public string FileName { get; set; }

    [Required(ErrorMessage = "This field is required")]
    [MinLength(5, ErrorMessage = "5 characters is required")]
    public string FolderName { get; set; }
}

FirebaseStorageApp.Services

Esta es nuestra capa de servicio en donde conectaremos con firebase.
Para ello debemos instalar dos nugget package, FirebaseAuthentication.net y FirebaseStorage.net:

Una vez descargados ya podemos concectarnos con la siguiente clase:



public static class FirebaseStorageService
{
    private static readonly string _apiKey = Environment.GetEnvironmentVariable("API_KEY_STORAGE");
    private static readonly string _bucket = Environment.GetEnvironmentVariable("BUCKET_STORAGE");
    private static readonly string _email = Environment.GetEnvironmentVariable("AUTH_EMAIL");
    private static readonly string _Password = Environment.GetEnvironmentVariable("AUTH_PASWORD");

    public static StreamContent ConvertBase64ToStream(string fileBase64)
    {
        byte[] stringToBase64 = Convert.FromBase64String(fileBase64);
        StreamContent streamContent = new(new MemoryStream(stringToBase64));
        return streamContent;
    }

    public static async Task<string> UploadFile(Stream stream, FileModel file)
    {
        string fileFromFirebaseStorage = string.Empty;
        FirebaseAuthProvider firebaseConfiguration = new(new FirebaseConfig(_apiKey));

        FirebaseAuthLink authConfiguration = await firebaseConfiguration
            .SignInWithEmailAndPasswordAsync(_email, _Password);

        CancellationTokenSource cancellationToken = new();

        FirebaseStorageTask storageManager = new FirebaseStorage(_bucket,
            new FirebaseStorageOptions
            {
                AuthTokenAsyncFactory = () => Task.FromResult(authConfiguration.FirebaseToken),
                ThrowOnCancel = true
            })
            .Child(file.FolderName)
            .Child(file.FileName)
            .PutAsync(stream, cancellationToken.Token);

        try
        {
            fileFromFirebaseStorage = await storageManager;
        }
        catch (Exception e)
        {
        }
        return fileFromFirebaseStorage;
    }
}

Explicado el codigo de forma general ya estamos en condiciones de cargar nuestros archivo. En el siguiente link puedes obtener el json dejemplo para probar la api: Example Body

Al ejecutar el post el endpoint nos devolvera la url para visualizar el documento cargado:



{
  "fileUrlFirebase": "https://firebasestorage.googleapis.com/v0/b/pruebas-fc979.appspot.com/o/documents%2Fpdf_prueba?alt=media&token=6a52c316-661a-48b6-8505-206f3a4b202a"
}

Si revisamos en la consola veremos el nuevo archivo cargado

💼 Mi Portafolio