Ocelot
.NETAPI GatewayOcelot

Creando API Gateway en .NET con Ocelot

En este tutorial, te enseñaré cómo utilizar Ocelot para crear un API Gateway en .NET de forma fácil y rápida. Aprenderás cómo instalar y configurar Ocelot, y cómo exponer servicios a través del API Gateway utilizando esta potente herramienta de código abierto. Si quieres aprender a utilizar Ocelot ¡este tutorial es para ti!

En el código de ejemplo crearemos 3 microservicios y un API Gateway con Ocelot, que actuará como un intermediario entre los clientes y los servicios.

Empecemos con un poquito de teoría? y después pasemos al código

  1. ¿Qué es un API Gateway y por qué es útil?
  2. ¿Qué es Ocelot y cómo funciona?
  3. ¿Por qué usar puerta de enlace API en arquitectura de microservicios?
  4. Ejemplo de arquitectura de microservicios y API Gateway con Ocelot
  5. Cómo instalar y configurar Ocelot en un proyecto .NET
  6. Cómo exponer servicios a través del API Gateway utilizando Ocelot
  7. Cómo implementar algunas características de Ocelot
    1. El patrón de agregación en puertas de enlace API con Ocelot
    2. Autenticación en puertas de enlace API con Ocelot
    3. Autorización en puertas de enlace API con Ocelot
    4. Limitación de tasa en puertas de enlace API con Ocelot
    5. Delegating Handlers en puertas de enlace API con Ocelot
    6. Almacenamiento en caché en puertas de enlace API con Ocelot

¿Qué es un API Gateway y por qué es útil?

Una puerta de enlace de API (API Gateway) es una capa que se utiliza en arquitecturas de microservicios para proporcionar una capa de abstracción entre clientes y servicios.

Esencialmente, es un punto de entrada único para dirigir el tráfico a varios microservicios y un lugar central donde se pueden implementar la seguridad, la orquestación, la monitorización, la transformación de protocolos y otros requisitos no funcionales. En lugar de exponer cada servicio de forma individual a través de su propia dirección IP y puerto, se expone una sola dirección IP y puerto para el API Gateway, que enruta las solicitudes a los servicios adecuados.

¿Qué es Ocelot y cómo funciona?

Ocelot es una herramienta de enrutamiento y puerta de enlace de API de código abierto para .NET que nos permite a los desarrolladores crear puertas de enlaces de API personalizadas.

Con Ocelot, podemos implementar características como el enrutamiento, la autenticación, autorización, la limitación, el balanceo de carga, almacenamiento en caché, la transformación de las respuestas, la orquestación y la monitorización, entre otros aspectos, de forma sencilla y eficiente, lo que mejora la eficiencia de la implementación y la escalabilidad de la aplicación.

Ocelot se utiliza para proporcionar un punto de entrada único y central para las solicitudes a varios microservicios. Utiliza un archivo de configuración para definir las rutas de enrutamiento y las políticas de seguridad.

¿Por qué usar puerta de enlace API en arquitectura de microservicios?

La arquitectura de microservicios ha visto un aumento significativo en popularidad en los últimos años, principalmente debido a una mayor escalabilidad, flexibilidad y rendimiento.

Dado que las aplicaciones basadas en microservicios comprenden varios servicios diferentes, a menudo necesitamos una interfaz o puerta de enlace común para llamar a estos servicios, de modo que podamos definir y administrar todas las preocupaciones en un solo lugar, en vez de replicarlas en todos los servicios posteriores.

Aquí es precisamente donde entra en juego una puerta de enlace API, que proporciona un punto de entrada único para dirigir el tráfico a varios microservicios y un lugar central donde se implementar la seguridad, la orquestación, la monitorización, etc.

Sin una puerta de enlace, habría que implementarlo en cada uno de los servicios y, por lo tanto, mantenerlo sería una tarea desalentadora.

En resumen, podemos aprovechar una puerta de enlace de API para centralizar, administrar y monitorear los requisitos no funcionales de una aplicación, orquestar los microservicios multifuncionales y reducir los viajes de ida y vuelta. Al administrar las solicitudes de manera consistente, una puerta de enlace API puede ayudar a reducir la latencia y mejorar la seguridad.

Beneficios de un API Gateway en arquitectura de microservicios

Mejora el aislamiento, al evitar el acceso directo a problemas internos.

  • Permite crear una interfaz única para llamar a varios servicios.
  • Permite agregar más servicios o cambiar los límites sin afectar a los clientes externos.

Seguridad mejorada al proporcionar una capa de seguridad.

  • Mejora la seguridad al proporcionar una capa de seguridad adicional, ya que no es necesario exponer los microservicios directamente.
  • Proporciona una capa de seguridad que puede ayudar a prevenir de ataques como inyección SQL, denegación de servicio (DoS), etc.
  • Proporciona un mecanismo de cifrado de extremo a extremo para proteger la información que se transmite entre los servicios y la API Gateway.
  • Permite limitar el tráfico entrante y saliente para evitar ataques de denegación de servicio.

Lugar para monitorización.

  • Dado que una API Gateway es un componente único a través del cual fluyen todas las solicitudes y respuestas, es un excelente lugar para recopilar métricas.
  • Ocelot proporciona una variedad de métricas y registros para ayudar a los desarrolladores a supervisar y solucionar problemas.

Elimina duplicación de código y, por lo tanto, reduce el esfuerzo de implementación.

  • Permite a los desarrolladores centralizar la gestión de la seguridad, la autenticación, el enrutamiento y el cumplimiento en un solo lugar, lo que ahorra tiempo y esfuerzo en el desarrollo y mantenimiento de la aplicación.

Mejora la latencia.

  • Ayuda a reducir la latencia al dividir una solicitud en varias solicitudes si es necesario y luego enrutarlas al servicio apropiado.
  • Al proporcionar un punto de entrada único para todas las solicitudes, Ocelot reduce el número de viajes de ida y vuelta necesarios para obtener una respuesta.
  • Si un usuario de un servicio en particular necesita datos de varios servicios, debe autenticar al usuario solo una vez, lo que reduce la latencia y hace que su mecanismo de autenticación sea coherente en toda la aplicación.

¡Veamos el código!👇

Ahora que sabemos qué es un API Gateway. Si tu café☕está listo comencemos.

Ejemplo de arquitectura de microservicios y API Gateway con Ocelot

En el caso práctico, crearemos 3 microservicios y una puerta de enlace API con Ocelot, que actuará como un intermediario entre las apps y los servicios, permitiendo a los clientes acceder a los servicios.

Tecnologías

Cómo instalar y configurar Ocelot en un proyecto .NET

1. Creamos una solución en blanco con el nombre «API-Gateway-Ocelot»

2. Empezaremos creando 2 proyectos de tipo ASP.NET Core Web API, que seran nuestros microservicios de ejemplo. «Servicio A» para obtener posts y «Servicio B» para obtener users.

No vamos a entrar en detalle de cómo crear estos microservicios, porque no es el fin de este tutorial. El código de los microservicios utilizados en este ejemplo se pueden ver y descargar desde el repositorio, dejo enlace de descarga al final del artículo.

3. Ahora, crearemos un proyecto llamado «OCELOT API Gateway» de tipo ASP.NET Core Web API, este proyecto será nuestra puerta de enlace de API. El punto de entrada para dirigir el tráfico al resto de servicios.

4. Instalamos paquete NuGet de Ocelot

Install-Package Ocelot

5. Configuración inicial de Ocelot, los elementos principales a tener en cuenta son AddOcelot() que agrega servicios de Ocelot y UseOcelot().Wait() que configura todo el middleware de Ocelot.

using Ocelot.DependencyInjection;
using Ocelot.Middleware;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddOcelot();

var app = builder.Build();

app.UseOcelot().Wait();

app.Run();

6. Creamos «ocelot.json», que es el archivo de configuración en el que especificamos las rutas y reglas de enrutamiento para la puerta de enlace API. En este archivo podemos definir diversas reglas para controlar cómo se redirige el tráfico hacia los microservicios.

7. Agregamos el archivo de configuración JSON que hemos creado con AddJsonFile().

using Ocelot.DependencyInjection;
using Ocelot.Middleware;

var builder = WebApplication.CreateBuilder(args);

builder.Configuration.AddJsonFile("ocelot.json", optional: false, reloadOnChange: true);

builder.Services.AddOcelot();

var app = builder.Build();

app.UseOcelot().Wait();

app.Run();

8. Por último, en propiedades de archivo «ocelot.json» cambiamos a «copiar siempre», para que se actualice al compilar.

Cómo exponer servicios a través del API Gateway utilizando Ocelot

Una vez creado nuestros microservicios y puerta de enlace, vamos a las configuraciones para exponer servicios a través de la puerta de enlace API.

1. Editamos archivo de configuración «ocelot.json» y añadimos:

  • Routes: la funcionalidad principal de Ocelot es recibir solicitudes http entrantes y reenviarlas a un servicio descendente. Ocelot describe el enrutamiento de una solicitud a otra como una ruta. Para configurar una ruta, debemos agregar un array llamado Routes:
    • DownstreamPathTemplate, DownstreamScheme y DownstreamHostAndPorts definen la URL a la que se reenviará una solicitud. DownstreamHostAndPorts es un array porque Ocelot te permite agregar más de una entrada y luego seleccionar un equilibrador de carga.
    • UpstreamPathTemplate es la URL que utilizará Ocelot para identificar qué DownstreamPathTemplate utilizar para una solicitud determinada. UpstreamHttpMethod se usa para que Ocelot pueda distinguir entre solicitudes con diferentes verbos HTTP a la misma URL(si el array está vacío acepta todos los verbos).
  • GlobalConfiguration: Ocelot necesita saber la BaseUrl bajo la que se ejecuta para buscar y reemplazar encabezados y para ciertas configuraciones de administración.
{
  "Routes": [
    {
      "DownstreamPathTemplate": "/posts",
      "DownstreamScheme": "https",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 7019
        }
      ],
      "UpstreamPathTemplate": "/api/posts",
      "UpstreamHttpMethod": [ "Get" ]
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "https://localhost:5000"
  }
}

2. Configuramos «launchSettings.json», que contiene la configuración que controla el modo en que se inicia la aplicación web en el equipo de desarrollo:

{
  "$schema": "https://json.schemastore.org/launchsettings.json",
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:44343",
      "sslPort": 5000
    }
  },
  "profiles": {
    "OCELOT-API-Gateway": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "launchUrl": "todos",
      "applicationUrl": "https://localhost:5000;",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

3. Por último, para iniciar múltiples proyectos a la vez, nos vamos a propiedades de la solución, en «Proyecto de inicio», seleccionamos «Proyectos de inicio múltiples» y seleccionamos «Iniciar» en todos los proyectos.

Y en este momento, si iniciamos aplicaciones y vamos a la siguiente url: https://localhost:5000/todos/1 ¡Ya podemos acceder a nuestra API Gateway! ?

También puedes hacer una captura de todo tipo de ruta usando {everything}:

{
  "DownstreamPathTemplate": "/{everything}",
  "DownstreamScheme": "https",
  "DownstreamHostAndPorts": [
    {
      "Host": "localhost",
      "Port": 7019
    }
  ],
  "UpstreamPathTemplate": "/api/{everything}",
  "UpstreamHttpMethod": [ "Get" ]
}

Esto reenviará cualquier combinación de ruta + cadena de consulta al servicio descendente después de la ruta /api. Para probar las siguientes urls: https://localhost:5000/api/posts; https://localhost:5000/api/posts/1

Cómo implementar algunas características de Ocelot

  1. El patrón de agregación en puertas de enlace API con Ocelot
  2. Autenticación en puertas de enlace API con Ocelot
  3. Autorización en puertas de enlace API con Ocelot
  4. Limitación de tasa en puertas de enlace API con Ocelot
  5. Delegating Handlers en puertas de enlace API con Ocelot
  6. Almacenamiento en caché en puertas de enlace API con Ocelot

El patrón de agregación en puertas de enlace API con Ocelot

Ocelot nos permite especificar rutas agregadas que componen varias rutas normales y mapean sus respuestas en un solo objeto. De esta manera un cliente que realiza múltiples solicitudes a un servidor, ahora podría ser solo una.

1. Agregamos al archivo de configuración de Ocelot un array llamado Aggregates.

El objeto dentro de la lista RouteKeys describe una agregación de dos servicios, identificados por las claves de ruta «posts» y «users». La propiedad UpstreamPathTemplate establece la plantilla de la ruta que se usará para el servicio principal, en este caso es «/».

La propiedad Aggregator define el nombre de la clase que implementa la lógica de agregación, en este caso PostsUserAggregator.

{
  "Routes": [
    {
      ...
      "Key": "posts"
    },
    {
      ...
      "Key": "users"
    }
  ],
  "GlobalConfiguration": {
    ...
  },
  "Aggregates": [
    {
      "RouteKeys": [
        "posts",
        "users"
      ],
      "UpstreamPathTemplate": "/",
      "Aggregator": "PostsUserAggregator"
    }
  ]
}

2. Creamos clase «PostsUserAggregator» que hereda de IDefinedAggregator.  Esta clase será responsable de tomar las respuestas de los servicios «posts» y «users» y combinarlas en una sola respuesta. Ocelot buscará este agregador cuando intente acceder a esta ruta.

public class PostsUserAggregator : IDefinedAggregator
{
    public async Task<DownstreamResponse> Aggregate(List<HttpContext> responses)
    {
        var posts = await responses[0].Items.DownstreamResponse().Content.ReadFromJsonAsync<List<PostDto>>();
        var users = await responses[1].Items.DownstreamResponse().Content.ReadFromJsonAsync<List<UserDto>>();

        posts?.ForEach(post =>
        {
            post.User = users.FirstOrDefault(a => a.Id == post.UserId);
        });

        var jsonString = JsonConvert.SerializeObject(posts, Formatting.Indented, new JsonConverter[] { new StringEnumConverter() });

        var stringContent = new StringContent(jsonString)
        {
            Headers = { ContentType = new MediaTypeHeaderValue("application/json") }
        };

        return new DownstreamResponse(stringContent, HttpStatusCode.OK, new List<KeyValuePair<string, IEnumerable<string>>>(), "OK");
    }
}

3. Para que el agregador esté disponible, debemos agregar una instancia singleton del tipo de agregador PostsUserAggregator:

builder.Services
    .AddOcelot()
    .AddSingletonDefinedAggregator<PostsUserAggregator>();

4. Ahora ya podemos acceder a este agregado y obtener posts y usuarios en una sola llamada desde dos microservicios diferentes, mediante url https://localhost:5000/api/posts-user

[
{
    "Id": 1,
    "Title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
    "Body": "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam...",
    "UserId": 1,
    "User": {
        "Id": 1,
        "Name": "Leanne Graham",
        "Username": "Bret",
        "Email": "Sincere@april.biz",
        "Address": {
            "Street": "Kulas Light",
            "Suite": "Apt. 556",
            "City": "Gwenborough",
            "Zipcode": "92998-3874",
            "Geo": {
                "Lat": "-37.3159",
                "Lng": "81.1496"
            }
        },
        "Phone": "1-770-736-8031 x56442",
        "Website": "hildegard.org",
        "Company": {
            "Name": "Romaguera-Crona",
            "CatchPhrase": "Multi-layered client-server neural-net",
            "Bs": "harness real-time e-markets"
        }
    }
},
...
]

Nota: La agregación sólo admite el verbo GET HTTP.

Autenticación en puertas de enlace API con Ocelot

Ocelot nos permite securizar mediante la autenticación a nivel de rutas dentro del contexto de la puerta de enlace API.

1. En primer lugar, vamos a crear un nuevo servicio llamado «ServicioAuthentication», que nos hará falta para obtener el token, que usaremos para conectarnos a resto de microservicios. No vamos a entrar en detalle cómo implementar la lógica que nos devuelve el token. Un token se proporciona a un cliente después de que se haya autenticado y este token puede ser enviado por el cliente en todas las solicitudes posteriores para autenticar y autorizar la acción solicitada. Dejo enlace de descarga al final del artículo.

2. Ahora, vamos a configurar la autenticación en nuestra puerta de enlace API, necesitamos instalar el paquete NuGet «AspNetCore.Authentication.JwtBearer»

Install-Package Microsoft.AspNetCore.Authentication.JwtBearer

3. Para autenticar una ruta, en primer lugar, debemos registrar los servicios de autenticación en «program.cs» de nuestra puerta de enlace API:

builder.Services
    .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,

            ValidIssuer = builder.Configuration["JwtSettings:Issuer"],
            ValidAudience = builder.Configuration["JwtSettings:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["JwtSettings:Key"]))
        };
    });

    ...

    app.UseAuthorization();

4. Después añadimos Issuer, Audience y Key al archivo de configuración «appsettings.json» de nuestra puerta de enlace API (estos datos lo podemos obtener del «appsettings.json» del «ServicioAutenticación»):

{
  ...
  "AllowedHosts": "*",
  "JwtSettings": {
    "Issuer": "arbems.com",
    "Audience": "Public",
    "Key": "G3VF4C6KFV43JH6GKCDFGJH45V36JHGV3H4C6F3GJC63HG45GH6V345GHHJ4623FJL3HCVMO1P23PZ07W8"
  }
}

5. El siguiente código configura una ruta específica en la puerta de enlace API para requerir autenticación de token JWT. Se especifica que el proveedor de autenticación a usar es «Bearer» y se especifica que no hay ámbitos (scopes) permitidos específicos para acceder a esta ruta. Esto significa que todo token válido emitido por el emisor y destinatario especificados será permitido para acceder a esta ruta, sin importar los ámbitos incluidos en el token.

"Routes": [
    {
      ...
      "AuthenticationOptions": {
        "AuthenticationProviderKey": "Bearer",
        "AllowedScopes": []
      },
      ...
    }

Si accedemos a la ruta https://localhost:5000/api/posts que es la que hemos securizado con autenticación, sin añadir token obtenemos 401 Unauthorized

6. Necesitamos el token para ser autorizados a acceder a los recursos protegidos hasta que el token sea revocado o expire, lo obtenemos llamando al microservicio «ServicioAutenticacion», con los siguientes enlaces y parámetros:

Copiamos el token obtenido y probamos nuevamente acceder a la ruta desde Postman que es una aplicación que nos permite testear APIs a través de una interfaz gráfica de usuario:

!Ahora ya estamos autenticados, podemos acceder a la ruta y ver los resultados¡✌

Autorización en puertas de enlace API con Ocelot

Ocelot admite la autorización basada en notificaciones que se ejecuta después de la autenticación. Esto significa que podemos securizar una ruta mediante la autorización.

1. Agregamos una propiedad de una ruta llamada RouteClaimsRequirement a nuestra configuración de ruta. Esta propiedad especifica un requisito para acceder a esta ruta en particular. En este caso, se establece que el usuario debe tener un reclamo UserType con un valor «authorized» para poder acceder a esta ruta.

Esto significa que solo los usuarios que cumplan con el requisito (es decir, que tienen una afirmación «UserType» con un valor «authorized» en su token de autorización) serán autorizados a acceder a la ruta especificada. Si un usuario no cumple con el requisito, recibirá un error de autorización y no podrá acceder a la ruta, recibiendo una respuesta 403 prohibida

...
"RouteClaimsRequirement": {
    "UserType": "authorized"
}
...

Obteniendo el token con este enlace: https://localhost:5000/api/token?username=user&userType=unauthorized no estarás autorizado. Con el siguiente enlace si, https://localhost:5000/api/token?username=admin&userType=authorized

!Ahora ya tenemos protegidas las rutas según autorizaciones del usuario!?‍♂️

Limitación de tasa en puertas de enlace API con Ocelot

Ocelot admite la limitación de tasa de las solicitudes ascendentes para que sus servicios descendentes no se sobrecarguen.

Esta configuración define la implementación de limitación de tasa en Ocelot. La propiedad EnableRateLimiting activa o desactiva la limitación de tasa. La propiedad ClientWhitelist es una lista de clientes permitidos que están exentos de limitación de tasa. La propiedad Period especifica el intervalo de tiempo en el que se aplica la limitación de tasa. La propiedad PeriodTimespan es el número de intervalos de tiempo en el que se aplica la limitación de tasa. La propiedad Limit especifica el número de solicitudes permitidas en el intervalo de tiempo especificado.

En este caso, la limitación de tasa se aplica a 1 solicitud por segundo para todos los clientes excepto aquellos incluidos en la lista blanca.

"RateLimitOptions": {
    "ClientWhitelist": [],
    "EnableRateLimiting": true,
    "Period": "1s",
    "PeriodTimespan": 1,
    "Limit": 1
}

También podemos configurar lo siguiente en la parte GlobalConfiguration de ocelot.json.

"RateLimitOptions": {
  "DisableRateLimitHeaders": false,
  "QuotaExceededMessage": "Customize Tips!",
  "HttpStatusCode": 999,
  "ClientIdHeader" : "Test"
}

Las opciones incluidas en este bloque permiten personalizar el comportamiento de la puerta de enlace en caso de que se supere el límite de tasa establecido.

DisableRateLimitHeaders permite desactivar los encabezados relacionados con el límite de tasa.

QuotaExceededMessage permite personalizar el mensaje que se muestra cuando se supera el límite de tasa.

HttpStatusCode permite establecer un código de estado HTTP personalizado para los casos en los que se supera el límite de tasa.

ClientIdHeader permite establecer el encabezado que se utiliza como identificador del cliente para el límite de tasa.

Delegating Handlers en puertas de enlace API con Ocelot

Ocelot permite al usuario agregar controladores de delegación al transporte HttpClient. Se puede usar para interceptar cualquier solicitud y realizar una validación, por ejemplo, o incluso poner algún registro para monitorear. Como su nombre lo indica, básicamente los controladores de delegación son controladores de mensajes. Las solicitudes y devoluciones pasan por ellos.

1. En primer lugar, vamos a crear una clase, llamada «BlackListHandler» que herdará la clase DelegatingHandler (de la biblioteca System.Net.Http) e implementaremos el método SendAsync().

public class ApiKeyHandler : DelegatingHandler
{
    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        return base.SendAsync(request, cancellationToken);
    }
}

2. A continuación, debemos agregar los controladores al contenedor de Ocelot:

builder.Services
    .AddOcelot()
    .AddDelegatingHandler<ApiKeyHandler>(true);

3. Ahora, necesitamos configurar Ocelot para considerar DelegatingHandler en todas las solicitudes. Para hacer esto, agregaremos una nueva propiedad llamada DelegatingHandlers al archivo ocelot.json, donde pasaremos el nombre de la clase:

{
  ...
  "DelegatingHandlers": [
    "ApiKeyHandler"
  ]
}

4. Ahora vamos a agregar una validación de ejemplo. En este caso validar que recibimos un Header en concreto, si no lo recibimos lanzaremos una excepción:

public class ApiKeyHandler : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        if (!ValidateKey(request))
        {
            var response = new HttpResponseMessage(HttpStatusCode.BadRequest);
            return response;
        }
        return await base.SendAsync(request, cancellationToken);
    }

    private bool ValidateKey(HttpRequestMessage request)
    {
        if (request.Headers.TryGetValues("ApiKey", out IEnumerable<string> myHeaderList))
        {
            var myHeader = myHeaderList.First();

            //do something with the header value
            if (!string.IsNullOrEmpty(myHeader) && myHeader == "123456")
                return true;
        }

        return false;
    }
}

5. Probamos desde Postman y añadimos ApiKey con valor 123456. Si no añadimos header obtendremos un error 400 Bad Request

Almacenamiento en caché en puertas de enlace API con Ocelot

Ocelot admite un almacenamiento en caché proporcionado por CacheManager, mostraremos cómo agregar CacheManager a Ocelot para que pueda realizar el almacenamiento en caché de salida.

1. En primer lugar, instalamos paquete Nuget de CacheManager

Install-Package Ocelot.Cache.CacheManager

2. En segundo lugar, configuramos el servicio en program.cs

...
builder.Services.AddOcelot()
    .AddCacheManager(x =>
    {
        x.WithDictionaryHandle();
    })
...

3. Finalmente, para usar el almacenamiento en caché en una ruta agregamos configuración:

{
  ...
  "FileCacheOptions": {
    "TtlSeconds": 15,
    "Region": "somename"
  }
  ...
}

Con TtlSeconds se establece el tiempo de vida en segundos de los elementos en la caché de archivos. Con Region se especifica el nombre de la región para la caché de archivos. Al usar la caché de archivos, Ocelot puede reducir el número de solicitudes al back-end y mejorar el rendimiento de la aplicación.

Para probar accedemos a la ruta https://localhost:5000/api/users los resultado se almacenarán en memoria caché y caducarán después de 15 segundos.

Conclusión

En conclusión, Ocelot es una excelente opción para implementar un API Gateway en aplicaciones .NET. Ofrece una gran cantidad de características útiles, como enrutamiento, transformación de peticiones y respuestas, autenticación y autorización, y muchas más. Además, es fácil de configurar y personalizar, lo que lo hace ideal para proyectos de todos los tamaños. Si estás buscando una solución para implementar un API Gateway en tu aplicación .NET, definitivamente debes considerar usar Ocelot.

Eso es todo por el momento, seguiré actualizando y agregando contenido en este post. Espero que te haya resultado interesante😉

Descargas

El código fuente de este artículo se puede encontrar en GitHub

Dependency Injection

Vida útil de los servicios: Transient, Scoped & Singleton en ASP.NET Core

Contenedor

Creando un contenedor de Docker para una aplicación .NET

CQRS con MediatR en .NET 6

Dapper

Dapper y Entity Framework Core en .NET 6

Clean architecture en .NET y C#