Inicio rápido: Uso de Azure Cache for Redis con una aplicación web de ASP.NET

En este inicio rápido usará Visual Studio 2019 para crear una aplicación web de ASP.NET que se conecte a Azure Redis Cache para almacenar y recuperar datos de la caché. Después implementará la aplicación en Azure App Service.

Ir al código en GitHub

Si quiere pasar directamente al código, consulte Inicio rápido: Uso de Azure Cache for Redis con una aplicación web de ASP.NET en GitHub.

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita
• Visual Studio 2019 con las cargas de trabajo ASP.NET y desarrollo web y desarrollo de Azure.

Creación del proyecto de Visual Studio

1. Abra Visual Studio y seleccione Archivo > Nuevo > Proyecto.

2. En el cuadro de diálogo Crear un proyecto, siga estos pasos:

   

   a. En el cuadro de búsqueda, escriba Aplicación web ASP.NET de C# .

   b. Seleccione Aplicación web ASP.NET (.NET Framework).

   c. Seleccione Next (Siguiente).

3. En el cuadro Nombre de proyecto, asigne un nombre al proyecto. En este ejemplo, hemos usado ContosoTeamStats.

4. Asegúrese de que se selecciona .NET Framework 4.6.1, o cualquier versión superior.

5. Seleccione Crear.

6. Seleccione MVC como tipo de proyecto.

7. Asegúrese de especificar Sin autenticación en la opción Autenticación. Dependiendo de la versión de Visual Studio, puede establecerse otro valor predeterminado de autenticación. Para cambiarlo, seleccione Cambiar autenticación y después Sin autenticación.

8. Seleccione Crear para crear el proyecto.

Creación de una caché

A continuación, creará la caché de la aplicación.

1. Para crear una instancia de caché, inicie sesión en Azure Portal y seleccione Crear un recurso.

   

2. En la página Nuevo, seleccione Base de datos y, a continuación, seleccione Azure Cache for Redis.

   

3. En la página Nueva instancia de Redis Cache, configure las opciones de la nueva caché.

   Configuración	Elegir un valor	Descripción
   Suscripción	Desplácese hacia abajo y seleccione su suscripción.	La suscripción en la que se creará esta nueva instancia de Azure Cache for Redis.
   Grupos de recursos	Desplácese hacia abajo y seleccione un grupo de recursos o Crear nuevo y escriba un nombre nuevo para el grupo de recursos.	Nombre del grupo de recursos en el que se van a crear la caché y otros recursos. Al colocar todos los recursos de la aplicación en un grupo de recursos, puede administrarlos o eliminarlos fácilmente.
   Nombre DNS	Escriba un nombre único.	El nombre de la memoria caché debe ser una cadena de entre 1 y 63 caracteres, y solo puede contener números, letras o guiones. El nombre debe comenzar y terminar por un número o una letra y no puede contener guiones consecutivos. El nombre de host de la instancia de caché será <DNS name>.redis.cache.windows.net.
   Ubicación	Desplácese hacia abajo y seleccione una ubicación.	Seleccione una región cerca de otros servicios que vayan a usar la memoria caché.
   Tipo de caché	Desplácese hacia abajo y seleccione un nivel.	El nivel determina el tamaño, rendimiento y características disponibles para la memoria caché. Para más información, consulte la introducción a Azure Redis Cache.

4. Seleccione la pestaña Redes o elija el botón Redes situado en la parte inferior de la página.

5. En la pestaña Redes, seleccione el método de conectividad.

6. Seleccione la pestaña Siguiente: Opciones avanzadas o seleccione el botón Siguiente: Opciones avanzadas en la parte inferior de la página.

7. En la pestaña Opciones avanzadas de una instancia de caché básica o estándar, seleccione el botón de alternancia de habilitación si desea habilitar un puerto que no sea TLS. También puede seleccionar la versión de Redis que quiere usar, 4 o 6.

   

8. En la pestaña Opciones avanzadas de la instancia de caché Premium, configure el puerto no TLS, la agrupación en clústeres y la persistencia de datos. También puede seleccionar la versión de Redis que quiere usar, 4 o 6.

9. Seleccione el botón Siguiente: Opciones avanzadas o elija el botón Siguiente: Etiquetas situado en la parte inferior de la página.

10. Opcionalmente, en la pestaña Etiquetas, escriba el nombre y el valor si desea clasificar el recurso.

11. Seleccione Revisar + crear. Pasará a la pestaña Revisar y crear, donde Azure validará la configuración.

12. Tras aparecer el mensaje verde Validación superada, seleccione Crear.

La caché tarda un tiempo en crearse. Puede supervisar el progreso en la página Información general de Azure Cache for Redis. Cuando Estado se muestra como En ejecución, la memoria caché está lista para su uso.

Recuperación del nombre de host, los puertos y las claves de acceso desde Azure Portal

Para conectar con una instancia de Azure Cache for Redis, los clientes de dicha caché necesitan el nombre de host, los puertos y una clave para la caché. Es posible que algunos clientes utilicen nombres ligeramente diferentes para estos elementos. Puede obtener el nombre de host, los puertos y las claves de Azure Portal.

• Para obtener las claves de acceso, en el panel de navegación izquierdo de Azure Cache for Redis, seleccione Claves de acceso.

  

• Para obtener el nombre de host y los puertos, en el panel de navegación izquierdo de Azure Cache for Redis, seleccione Propiedades. El nombre de host tiene el formato <DNS name>.redis.cache.windows.net.

  

Para editar el archivo CacheSecrets.config

1. Cree un archivo en el equipo llamado CacheSecrets.config. Colóquelo en una ubicación en la que no se pueda comprobar con el código fuente de la aplicación de ejemplo. En esta guía de inicio rápido, el archivo CacheSecrets.config se encuentra en C:\AppSecrets\CacheSecrets.config.

2. Edite el archivo CacheSecrets.config. Después, agregue el siguiente contenido:

   <appSettings>
       <add key="CacheConnection" value="<cache-name>.redis.cache.windows.net,abortConnect=false,ssl=true,allowAdmin=true,password=<access-key>"/>
   </appSettings>
   

3. Reemplace <cache-name> por su nombre de host de caché.

4. Reemplace <access-key> por la clave principal de la caché.

   Sugerencia

   Puede usar la clave de acceso secundaria durante la rotación de claves como una clave alternativa mientras vuelve a generar la clave de acceso principal.

5. Guarde el archivo.

Actualización de la aplicación MVC

En esta sección, actualizará la aplicación para admitir una nueva vista que muestra una prueba sencilla realizada para una instancia de Azure Redis Cache.

• Actualización del archivo web.config con una configuración de aplicación para la caché
• Configuración de la aplicación para usar el cliente de StackExchange.Redis
• Actualización de HomeController y Layout
• Adición de una nueva vista de RedisCache

Actualización del archivo web.config con una configuración de aplicación para la caché

Cuando se ejecuta la aplicación localmente, la información de CacheSecrets.config se usa para conectarse a la instancia de Azure Redis Cache. Más adelante se implementará esta aplicación en Azure. En ese momento, define una configuración de aplicación en Azure que la aplicación usa para recuperar la información de conexión de la caché en lugar de este archivo.

Como el archivo CacheSecrets.config no se ha implementado en Azure con la aplicación, solo lo usará al probar la aplicación localmente. Es importante mantener esta información lo más segura posible para impedir el acceso malintencionado a los datos de la caché.

Para actualizar el archivo web.config

1. En el Explorador de soluciones, haga doble clic en el archivo web.config para abrirlo.

   

2. En el archivo web.config, busque el elemento <appSetting>. Después, agregue el atributo file siguiente. Si utiliza un nombre de archivo o una ubicación diferente, sustituya los valores por los que se muestran en el ejemplo.

• Antes: <appSettings>
• Después: <appSettings file="C:\AppSecrets\CacheSecrets.config">

El sistema en tiempo de ejecución de ASP.NET combina el contenido del archivo externo con las marcas del elemento <appSettings> . El entorno de ejecución omite el atributo de archivo si no se encuentra el archivo especificado. Los secretos (cadena de conexión a la caché) no se incluyen como parte del código fuente de la aplicación. Al implementar la aplicación web en Azure, el archivo CacheSecrets.config no se implementará.

Para configurar la aplicación para que use StackExchange.Redis

1. Para configurar la aplicación para que use el paquete NuGet StackExchange.Redis para Visual Studio, seleccione Herramientas > Administrador de paquetes NuGet > Consola del Administrador de paquetes.

2. Ejecute el siguiente comando desde la ventana Package Manager Console:

   Install-Package StackExchange.Redis
   

3. El paquete NuGet descarga y agrega las referencias de ensamblado requeridas para que la aplicación cliente acceda a Azure Cache for Redis con el cliente StackExchange.Azure Cache for Redis. Si prefiere usar una versión con nombre seguro de la biblioteca de cliente StackExchange.Redis, instale el paquete StackExchange.Redis.

Para actualizar HomeController y Layout

1. En el Explorador de soluciones, expanda la carpeta Controllers y abra el archivo HomeController.cs.

2. Agregue las siguientes instrucciones using al principio del archivo.

   using StackExchange.Redis;
   using System.Configuration;
   using System.Net.Sockets;
   using System.Text;
   using System.Threading;
   

3. Agregue los siguientes miembros a la clase HomeController para admitir una nueva acción RedisCache que ejecuta algunos comandos en la nueva caché.

        public async Task<ActionResult> RedisCache()
       {
           ViewBag.Message = "A simple example with Azure Cache for Redis on ASP.NET.";
   
           if (Connection == null)
           {
               await InitializeAsync();
           }
   
           IDatabase cache = await GetDatabaseAsync();
   
           // Perform cache operations using the cache object...
   
           // Simple PING command
           ViewBag.command1 = "PING";
           ViewBag.command1Result = cache.Execute(ViewBag.command1).ToString();
   
           // Simple get and put of integral data types into the cache
           ViewBag.command2 = "GET Message";
           ViewBag.command2Result = cache.StringGet("Message").ToString();
   
           ViewBag.command3 = "SET Message \"Hello! The cache is working from ASP.NET!\"";
           ViewBag.command3Result = cache.StringSet("Message", "Hello! The cache is working from ASP.NET!").ToString();
   
           // Demonstrate "SET Message" executed as expected...
           ViewBag.command4 = "GET Message";
           ViewBag.command4Result = cache.StringGet("Message").ToString();
   
           // Get the client list, useful to see if connection list is growing...
           // Note that this requires allowAdmin=true in the connection string
           ViewBag.command5 = "CLIENT LIST";
           StringBuilder sb = new StringBuilder();
           var endpoint = (System.Net.DnsEndPoint)(await GetEndPointsAsync())[0];
           IServer server = await GetServerAsync(endpoint.Host, endpoint.Port);
           ClientInfo[] clients = await server.ClientListAsync();
   
           sb.AppendLine("Cache response :");
           foreach (ClientInfo client in clients)
           {
               sb.AppendLine(client.Raw);
           }
   
           ViewBag.command5Result = sb.ToString();
   
           return View();
       }
   
       private static long _lastReconnectTicks = DateTimeOffset.MinValue.UtcTicks;
       private static DateTimeOffset _firstErrorTime = DateTimeOffset.MinValue;
       private static DateTimeOffset _previousErrorTime = DateTimeOffset.MinValue;
   
       private static SemaphoreSlim _reconnectSemaphore = new SemaphoreSlim(initialCount: 1, maxCount: 1);
       private static SemaphoreSlim _initSemaphore = new SemaphoreSlim(initialCount: 1, maxCount: 1);
   
       private static ConnectionMultiplexer _connection;
       private static bool _didInitialize = false;
   
       // In general, let StackExchange.Redis handle most reconnects,
       // so limit the frequency of how often ForceReconnect() will
       // actually reconnect.
       public static TimeSpan ReconnectMinInterval => TimeSpan.FromSeconds(60);
   
       // If errors continue for longer than the below threshold, then the
       // multiplexer seems to not be reconnecting, so ForceReconnect() will
       // re-create the multiplexer.
       public static TimeSpan ReconnectErrorThreshold => TimeSpan.FromSeconds(30);
   
       public static TimeSpan RestartConnectionTimeout => TimeSpan.FromSeconds(15);
   
       public static int RetryMaxAttempts => 5;
   
       public static ConnectionMultiplexer Connection { get { return _connection; } }
   
       public static async Task InitializeAsync()
       {
           if (_didInitialize)
           {
               throw new InvalidOperationException("Cannot initialize more than once.");
           }
   
           _connection = await CreateConnectionAsync();
           _didInitialize = true;
       }
   
       // This method may return null if it fails to acquire the semaphore in time.
       // Use the return value to update the "connection" field
       private static async Task<ConnectionMultiplexer> CreateConnectionAsync()
       {
           if (_connection != null)
           {
               // If we already have a good connection, let's re-use it
               return _connection;
           }
   
           try
           {
               await _initSemaphore.WaitAsync(RestartConnectionTimeout);
           }
           catch
           {
               // We failed to enter the semaphore in the given amount of time. Connection will either be null, or have a value that was created by another thread.
               return _connection;
           }
   
           // We entered the semaphore successfully.
           try
           {
               if (_connection != null)
               {
                   // Another thread must have finished creating a new connection while we were waiting to enter the semaphore. Let's use it
                   return _connection;
               }
   
               // Otherwise, we really need to create a new connection.
               string cacheConnection = ConfigurationManager.AppSettings["CacheConnection"].ToString();
               return await ConnectionMultiplexer.ConnectAsync(cacheConnection);
           }
           finally
           {
               _initSemaphore.Release();
           }
       }
   
       private static async Task CloseConnectionAsync(ConnectionMultiplexer oldConnection)
       {
           if (oldConnection == null)
           {
               return;
           }
           try
           {
               await oldConnection.CloseAsync();
           }
           catch (Exception)
           {
               // Ignore any errors from the oldConnection
           }
       }
   
       /// <summary>
       /// Force a new ConnectionMultiplexer to be created.
       /// NOTES:
       ///     1. Users of the ConnectionMultiplexer MUST handle ObjectDisposedExceptions, which can now happen as a result of calling ForceReconnectAsync().
       ///     2. Call ForceReconnectAsync() for RedisConnectionExceptions and RedisSocketExceptions. You can also call it for RedisTimeoutExceptions,
       ///         but only if you're using generous ReconnectMinInterval and ReconnectErrorThreshold. Otherwise, establishing new connections can cause
       ///         a cascade failure on a server that's timing out because it's already overloaded.
       ///     3. The code will:
       ///         a. wait to reconnect for at least the "ReconnectErrorThreshold" time of repeated errors before actually reconnecting
       ///         b. not reconnect more frequently than configured in "ReconnectMinInterval"
       /// </summary>
       public static async Task ForceReconnectAsync()
       {
           var utcNow = DateTimeOffset.UtcNow;
           long previousTicks = Interlocked.Read(ref _lastReconnectTicks);
           var previousReconnectTime = new DateTimeOffset(previousTicks, TimeSpan.Zero);
           TimeSpan elapsedSinceLastReconnect = utcNow - previousReconnectTime;
   
           // If multiple threads call ForceReconnectAsync at the same time, we only want to honor one of them.
           if (elapsedSinceLastReconnect < ReconnectMinInterval)
           {
               return;
           }
   
           try
           {
               await _reconnectSemaphore.WaitAsync(RestartConnectionTimeout);
           }
           catch
           {
               // If we fail to enter the semaphore, then it is possible that another thread has already done so.
               // ForceReconnectAsync() can be retried while connectivity problems persist.
               return;
           }
   
           try
           {
               utcNow = DateTimeOffset.UtcNow;
               elapsedSinceLastReconnect = utcNow - previousReconnectTime;
   
               if (_firstErrorTime == DateTimeOffset.MinValue)
               {
                   // We haven't seen an error since last reconnect, so set initial values.
                   _firstErrorTime = utcNow;
                   _previousErrorTime = utcNow;
                   return;
               }
   
               if (elapsedSinceLastReconnect < ReconnectMinInterval)
               {
                   return; // Some other thread made it through the check and the lock, so nothing to do.
               }
   
               TimeSpan elapsedSinceFirstError = utcNow - _firstErrorTime;
               TimeSpan elapsedSinceMostRecentError = utcNow - _previousErrorTime;
   
               bool shouldReconnect =
                   elapsedSinceFirstError >= ReconnectErrorThreshold // Make sure we gave the multiplexer enough time to reconnect on its own if it could.
                   && elapsedSinceMostRecentError <= ReconnectErrorThreshold; // Make sure we aren't working on stale data (e.g. if there was a gap in errors, don't reconnect yet).
   
               // Update the previousErrorTime timestamp to be now (e.g. this reconnect request).
               _previousErrorTime = utcNow;
   
               if (!shouldReconnect)
               {
                   return;
               }
   
               _firstErrorTime = DateTimeOffset.MinValue;
               _previousErrorTime = DateTimeOffset.MinValue;
   
               ConnectionMultiplexer oldConnection = _connection;
               await CloseConnectionAsync(oldConnection);
               _connection = null;
               _connection = await CreateConnectionAsync();
               Interlocked.Exchange(ref _lastReconnectTicks, utcNow.UtcTicks);
           }
           finally
           {
               _reconnectSemaphore.Release();
           }
       }
   
       // In real applications, consider using a framework such as
       // Polly to make it easier to customize the retry approach.
       private static async Task<T> BasicRetryAsync<T>(Func<T> func)
       {
           int reconnectRetry = 0;
           int disposedRetry = 0;
   
           while (true)
           {
               try
               {
                   return func();
               }
               catch (Exception ex) when (ex is RedisConnectionException || ex is SocketException)
               {
                   reconnectRetry++;
                   if (reconnectRetry > RetryMaxAttempts)
                       throw;
                   await ForceReconnectAsync();
               }
               catch (ObjectDisposedException)
               {
                   disposedRetry++;
                   if (disposedRetry > RetryMaxAttempts)
                       throw;
               }
           }
       }
   
       public static Task<IDatabase> GetDatabaseAsync()
       {
           return BasicRetryAsync(() => Connection.GetDatabase());
       }
   
       public static Task<System.Net.EndPoint[]> GetEndPointsAsync()
       {
           return BasicRetryAsync(() => Connection.GetEndPoints());
       }
   
       public static Task<IServer> GetServerAsync(string host, int port)
       {
           return BasicRetryAsync(() => Connection.GetServer(host, port));
       }
   

4. En el Explorador de soluciones, expanda la carpeta Vistas > Compartido. Después, abra el archivo _Layout.cshtml.

   Sustituya:

   @Html.ActionLink("Application name", "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })
   

   Por:

   @Html.ActionLink("Azure Cache for Redis Test", "RedisCache", "Home", new { area = "" }, new { @class = "navbar-brand" })
   

Para agregar una nueva vista de RedisCache

1. En el Explorador de soluciones, expanda la carpeta Vistas y, luego, haga clic con el botón derecho en la carpeta Inicio. Elija Agregar > Ver... .

2. En el cuadro de diálogo Agregar vista, escriba RedisCache como nombre de la vista. A continuación, seleccione Agregar.

3. Reemplace el código del archivo RedisCache.cshtml por el código siguiente:

   @{
       ViewBag.Title = "Azure Cache for Redis Test";
   }
   
   <h2>@ViewBag.Title.</h2>
   <h3>@ViewBag.Message</h3>
   <br /><br />
   <table border="1" cellpadding="10">
       <tr>
           <th>Command</th>
           <th>Result</th>
       </tr>
       <tr>
           <td>@ViewBag.command1</td>
           <td><pre>@ViewBag.command1Result</pre></td>
       </tr>
       <tr>
           <td>@ViewBag.command2</td>
           <td><pre>@ViewBag.command2Result</pre></td>
       </tr>
       <tr>
           <td>@ViewBag.command3</td>
           <td><pre>@ViewBag.command3Result</pre></td>
       </tr>
       <tr>
           <td>@ViewBag.command4</td>
           <td><pre>@ViewBag.command4Result</pre></td>
       </tr>
       <tr>
           <td>@ViewBag.command5</td>
           <td><pre>@ViewBag.command5Result</pre></td>
       </tr>
   </table>
   

Probar la aplicación localmente

De forma predeterminada, el proyecto está configurado para hospedar la aplicación localmente en IIS Express para pruebas y depuración.

Para ejecutar la aplicación localmente

1. En Visual Studio, seleccione Depurar > Iniciar depuración para crear e iniciar la aplicación localmente para pruebas y depuración.

2. En el explorador, seleccione Azure Redis Cache Test (Prueba de Azure Redis Cache) en la barra de navegación.

3. En el ejemplo siguiente, la clave Message tenía anteriormente un valor almacenado en caché, que se estableció mediante la consola de Azure Redis Cache en el portal. La aplicación actualizó ese valor almacenado en caché. La aplicación también ejecutó los comandos PING y CLIENT LIST.

   

Publicación y ejecución en Azure

Cuando haya probado con éxito la aplicación localmente, puede implementarla en Azure y ejecutarla en la nube.

Para publicar la aplicación en Azure

1. En Visual Studio, haga clic con el botón derecho en el nodo del proyecto en el Explorador de soluciones. Después, seleccione Publicar.

   

2. Seleccione Microsoft Azure App Service, después Crear nuevo y después seleccione Publicar.

   

3. En el cuadro de diálogo Crear servicio de aplicaciones, realice los cambios siguientes:

   Setting	Valor recomendado	Descripción
   Nombre de la aplicación	Use el valor predeterminado.	El nombre de la aplicación es el nombre de host de la aplicación cuando se implementa en Azure. El nombre puede tener un sufijo de marca de tiempo que se le agrega, si es necesario, para que sea único.
   Suscripción	Elija la suscripción de Azure.	En esta suscripción se cargan los costos de hospedaje relacionados. Si tiene varias suscripciones de Azure, compruebe que se selecciona la suscripción deseada.
   Grupos de recursos	Use el mismo grupo de recursos donde creó la caché (por ejemplo, TestResourceGroup).	El grupo de recursos le ayuda a administrar todos los recursos como un grupo. Más adelante, si desea eliminar la aplicación, puede eliminar simplemente el grupo.
   plan de App Service	Seleccione Nuevo y después cree un nuevo plan de App Service llamado TestingPlan. Use la misma ubicación que utilizó al crear la caché. Elija Libre para el tamaño.	Un plan de App Service define un conjunto de recursos de proceso con los que se ejecuta una aplicación web.

   

4. Después de definir la configuración del hospedaje de App Service, seleccione Crear.

5. Supervise la ventana Salida en Visual Studio para ver el estado de la publicación. Cuando se haya publicado la aplicación, se registra la dirección URL de la aplicación:

   

Adición de la configuración de aplicación para la caché

Cuando se publica la nueva aplicación, agregue una nueva configuración de aplicación. Esta configuración se usará para almacenar la información de conexión de caché.

Para agregar la configuración de aplicación

1. Escriba el nombre de la aplicación en la barra de búsqueda en la parte superior de Azure Portal para buscar la nueva aplicación que ha creado.

   

2. Agregue una nueva configuración de aplicación llamada CacheConnection para la aplicación que se usará para conectarse a la caché. Use el mismo valor que configuró para CacheConnection en el archivo CacheSecrets.config. El valor contiene la clave de acceso y el nombre de host de la caché.

   

Ejecutar la aplicación en Azure

En el explorador, vaya a la dirección URL de la aplicación. La dirección URL aparece en los resultados de la operación de publicación en la ventana de salida de Visual Studio. También se proporciona en Azure Portal en la página de información general de la aplicación que creó.

Seleccione Azure Redis Cache Test (Prueba de Azure Redis Cache) en la barra de navegación para probar el acceso a la memoria caché.

Limpieza de recursos

Si va a seguir con el tutorial siguiente, puede mantener los recursos creados en esta guía de inicio rápido y volverlos a utilizar.

En caso contrario, si ya ha terminado con la aplicación de ejemplo de la guía de inicio rápido, puede eliminar los recursos de Azure creados en este tutorial para evitar cargos.

Para eliminar un grupo de recursos

1. Inicie sesión en Azure Portal y después seleccione Grupos de recursos.

2. En el cuadro de texto Filtrar por nombre..., escriba el nombre del grupo de recursos. En las instrucciones de este artículo se usa un grupo de recursos llamado TestResources. En el grupo de recursos, en la lista de resultados, seleccione ... y, después, Eliminar grupo de recursos.

   

Se le pedirá que confirme la eliminación del grupo de recursos. Escriba el nombre del grupo de recursos para confirmar y, después, seleccione Eliminar.

Transcurridos unos instantes, el grupo de recursos y todos sus recursos se eliminan.

Pasos siguientes

En el siguiente tutorial, va a utilizar Azure Redis Cache en un escenario más realista para mejorar el rendimiento de una aplicación. Va a actualizar esta aplicación para almacenar en caché los resultados de la tabla de clasificación mediante el patrón cache-aside con ASP.NET y una base de datos.