Implementar una puerta de enlace con .NET Core y Ocelot – Parte II

En la entrada anterior, explicamos la primera parte de arquitectura de microservicios: cómo implementar una puerta de enlace con .NET Core y Ocelot. En esta entrada, vamos a finalizar tal tutorial.

Configuración Ocelot

Una vez tenemos ambos microservicios funcionando, podemos centrarnos en el proyecto Tienda, el que hará de API Gateway. Para configurarlo, primero es necesario instalar el packet NuGet de Ocelot, como hacemos a continuación: click derecho en el proyecto Tienda -> Manage NuGet Packages y buscamos el paquete para Ocelot.

A continuación, debemos realizar varios cambios en cómo se ejecuta el programa, primero en el archivo Startup.cs. Hay que modificar las funciones ConfigureServices y Configure para que carguen Ocelot, de la siguiente manera:

// This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddOcelot();
            services.AddControllers();
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "Tienda", Version = "v1" });
            });
        }

// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
                app.UseSwagger();
                app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "Tienda v1"));
            }

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>

            {
                endpoints.MapControllers();
            });
            app.UseOcelot().Wait();
        }

Y también hay que cambiar Program.cs para que use el archivo JSON ocelot.json, donde guardaremos la configuración manual de Ocelot y sus rutas.

public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                }).ConfigureAppConfiguration((hostingContext, config) =>
                {
                    config.AddJsonFile("ocelot.json");
                });

Configuración rutas Ocelot

Ahora añadimos el archivo ocelot.json al proyecto Tienda, haciendo Click Derecho -> New File -> JSON File.

Y lo vamos a rellenar con este contenido:

  "Routes": [
    {
      //Producto
      "DownstreamPathTemplate": "/api/Producto",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": "56023"
        }
      ],
      "UpstreamPathTemplate": "/apigateway/Producto",
      "UpstreamHttpMethod": [ "GET" ]
    },
    //Usuario
    {
      "DownstreamPathTemplate": "/api/Usuario",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": "36402"
        }
      ],
      "UpstreamPathTemplate": "/apigateway/Usuario",
      "UpstreamHttpMethod": [ "GET" ]
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "http://localhost:57123"
  }
}

Aquí lo que estamos configurando son las varias rutas, Downstream serían las de los microservicios. Indicamos cada una, que use http y su host y puerto exactos. Estos puertos son los mismos que hemos usado antes al hacer la comprobación, y los que presenta cada API.

Para cada ruta Downstream tenemos una Upstream, que es la que publica Ocelot, establecemos la URL y los métodos HTTP que se van a poder usar, en este caso es solo GET.

Comprobación rutas

Con la configuración de Ocelot completada podemos ejecutar todos los proyectos, y ver su funcionamiento. Individualmente tanto Producto y Usuario funcionan igual que antes, pero ahora podemos hacer peticiones al API Gateway y obtener los datos para ambas API, ya que hemos centralizado los microservicios.

Tal y como hemos escrito en ocelot.json si hacemos la petición a «/apigateway/Usuario” en el puerto del proyecto de ocelot, obtenemos los resultados como si hiciéramos la petición al microservicio de Usuario. Y también conseguimos resultados si lo hacemos lo equivalente para Producto.

Rate limiting con Ocelot

Ocelot es mucho más extensible y tiene más funcionalidades. La que vamos a demostrar aquí es el Rate Limiting, que nos permite bloquear las peticiones que excedan ciertos parámetros. En el archivo JSON añadimos debajo de la parte correspondiente el usuario, la configuración para hacer Rate Limiting. Esto debería resultar en que no se acepta más de una petición cada 5s, lo que establecemos con los parámetros Period: “5s” y Limit: 1.

{
  "Routes": [
    {
      //Producto
      "DownstreamPathTemplate": "/api/Producto",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": "56023"
        }
      ],
      "UpstreamPathTemplate": "/apigateway/Producto",
      "UpstreamHttpMethod": [ "GET" ]
    },
    //Usuario
    {
      "DownstreamPathTemplate": "/api/Usuario",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": "36402"
        }
      ],
      "RateLimitOptions": {
        "ClientWhitelist": [

        ],
        "EnableRateLimiting": true,
        "Period": "5s",
        "PeriodTimespan": 1,
        "Limit": 1
      },
      "UpstreamPathTemplate": "/apigateway/Usuario",
      "UpstreamHttpMethod": [ "GET" ]
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "http://localhost:57123"
  }
}

Podemos comprobar estos cambios volviendo a ejecutar la solución. Si intentamos hacer más de una petición cada 5s en lugar de los datos de la API, nos aparece esta respuesta:

Conclusión

En este artículo hemos desarrollado un ejemplo de arquitectura de microservicios usando Ocelot como API Gateway, y hemos hecho las comprobaciones de su funcionamiento. Lo que podemos observar es que es un sistema relativamente simple de configurar y prácticamente necesario para cualquier aplicación en que quisiéramos usar microservicios. Además, solo hemos explorado la funcionalidad base y el Rate Limiting, pero Ocelot ofrece muchas otras funciones que puede ser útiles y necesarias, desde Load Balancing a Autenticación y Caching.