Azure Cache Redis
En este Post se explica de forma detallada los pasos a seguir para poder almacenar objetos en Azure, Redis Cache.
Redis Cache es una herramienta de Azure que nos permite la facilidad de poder almacenar objetos en su base de datos, dichos objetos se almacenan mediante Json, pudiendo estos ser recuperados desde cualquier aplicación. A continuación, se explicará cómo crear un Redis Cache y como crear un proyecto para poder insertar, buscar y eliminar objetos, en este caso los objetos que vamos a insertar son jugadores de la NBA con un poco de su información básica.
Como ya se ha comentado para este proyecto necesitaremos dos elementos principales, siendo estos:
- Cache Redis. Para disponer de este elemento se necesitará de una cuenta en el portal de Azure, en el caso de no tenerla, deberás de hacerte con una.
- Proyecto Visual Studio
∙ En primer lugar vamos a crear el elemento Cache Redis. Nos dirigiremos al portal de Azure, y buscaremos “Redis Cache”, y seleccionamos el elemento que nos aparece.
Tras esto el elemento nos pedirá una información a cumplimentar para así poder configurar este componente.
Entre esta información se destacan dos opciones que son el Plan de tarifa, que vamos a seleccionar el básico, pues es el que menos gasta. Y la opción Desbloquear el puerto 6379, el cual es utilizado para conexiones no SSL. Tras rellenar la información de forma correcta, pulsamos en Crear. La creación de este elemento tardara en realizarse, con lo que podemos pasar a trabajar mientras a nuestro proyecto de Azure.
Una vez se haya creado nuestro Redis Cache, nos dirigimos a este, y en el panel principal que nos muestra nos vamos a Claves de acceso.
Una vez hallamos accedido deberemos de quedarnos con la Cadena de conexión principal, pues esta nos servirá para realizar la conexión entre nuestro proyecto y esa base de datos en la que almacenaremos los objetos.
∙ Hasta aquí ya habrías realizado todo lo necesario en el Portal de Azure, con lo que podemos pasar a nuestro proyecto en Visual Studio. Lo primero pues, será crearlo.
Para crear un proyecto debemos dirigirnos a la parte superior izquierda a File > New > Project…. Tras esto en la ventana modal seleccionamos el tipo de aplicación que vamos a crear, que en este caso será una de ASP.NET Web Applicaciont (.NET Framework). En la siguiente ventana marcaremos que la aplicación sea de tipo MVC, para así facilitarnos el trabajo de creación de carpetas y vistas.
Una vez creado el proyecto procedemos a insertar los NuGet necesarios, estos son:
- StackExchange.Redis, que nos permite trabajar con la base de datos Redis
- Newtonsoft.json, que nos permite poder almacenar objetos Json dentro del Cache Redis.
Para poder insertar estos NuGet a nuestro proyecto, pulsamos botón derecho en nuestro proyecto y seleccionamos Manage NuGet Packages…Una vez ahí los buscamos e instalamos, en el caso de que ya estén instalados por defecto, comprobamos si estos necesitan ser actualizados.
Tras esto, nos dirigimos al archivo Web.config, y en este debemos insertar la cadena de conexión que hemos obtenido anteriormente, de la siguiente manera:
<appSettings>
…
<add key=»NombreCualquiera»
value=»NuestraCadenaDeConexión»/>
</appSettings>
En nuestra cadena de conexión debemos fijarnos y modificar dos elementos para que esta funcione correctamente, estos son los siguientes:
–cacheazure.redis.cache.windows.net:6379
–ssl=false
Una vez realizado esto, pasamos a la obtención de los objetos. Para este ejemplo lo hemos realizado con un archivo xml, que hemos almacenado en una carpeta que hemos creado y llamado Documentos. La información almacenada en esta se encuentra de la siguiente manera:
Pasamos pues a crear la clase encargada de realizar la conexión con el Redis Cache. Para esto creamos una carpeta llamada Helpers, y dentro de esta una clase llamada AccesoCacheRedis.
En esta clase necesitaremos del método encargado de administrar la conexión con Azure Redis Cache. La forma más común de trabajar con este método, y de asegurarnos que existe solamente una instancia, es crear métodos que nos devuelvan los objetos en una clase Static. Esta clase deberá de tener este código:
public static class AccesoCacheRedis {
private static String CadenaConexionRedis = ConfigurationManager.AppSettings["NombreCualquiera "];
private static Lazy<ConnectionMultiplexer> CrearConexion = new Lazy<ConnectionMultiplexer>(() => {
return ConnectionMultiplexer.Connect(CadenaConexionRedis);
});
public static ConnectionMultiplexer Connection {
get {
return CrearConexion.Value;
}
}
}Hasta aquí ya tendríamos lo necesario para conectar nuestro proyecto con Azure Redis Cache. Ahora pasamos a la administración del objeto que queremos almacenar. Lo primero será dirigirnos a la carpeta Models, y en esta crear una clase con elementos que estén relacionados con el documento del que extraeremos la información.
Para este ejemplo vamos a crear una clase llamada Jugador.cs, y en esta crear los siguientes elementos:
public class Jugador {
public int IdJugador { get; set; }
public String Nombre { get; set; }
public String Equipo { get; set; }
public String Posicion { get; set; }
public String Imagen { get; set; }
}Con esto tendríamos el objeto que vamos a almacenar, Jugador. Pasamos ahora a realizar las funciones encargadas de seleccionar todos los jugadores y búsqueda de un jugador dentro del documento. Para esto debemos crear una carpeta llamada Repositories, y en esta una clase RepositoryJugadores. Dentro de esta clase dispondremos de este código:
public class RepositoryJugadores {
String uri;
public RepositoryJugadores(String uri) {
this.uri = uri;
}
public List<Jugador> GetJugadores() {
XDocument docxml = XDocument.Load(this.uri);
var consulta = from datos in docxml.Descendants("jugador")
select new Jugador{
IdJugador = int.Parse(datos.Element("idjugador").Value),
Nombre = datos.Element("nombre").Value,
Equipo = datos.Element("equipo").Value,
Posicion = datos.Element("posicion").Value,
Imagen = datos.Element("imagen").Value
};
return consulta.ToList();
}
public Jugador BuscarJugador(int idjugador) {
return this.GetJugadores().SingleOrDefault(z => z.IdJugador == idjugador);
}
}
–GetJugadores, se encarga de cargar todos los jugadores del archivo xml.
–BuscarJugador, recibe la id de un jugador y en función a esta, busca y devuelve la información de este.
A continuación, vamos a la carpeta Controllers, y en esta creamos un controlador llamado JugadoresController, este ha de ser MVC 5 Controller – Empty.
En este controlador debemos realizar la conexión con el repository creado anteriormente, para así poder llamar a las funciones ya creadas. Para la conexión con dicho repository necesitamos el siguiente código:
public RepositoryJugadores GetRepo() {
Uri uri = HttpContext.Request.Url;
String url = uri.Scheme + "://" + uri.Authority + "/Documentos/jugadores.xml";
return new RepositoryJugadores(url);
}Este se encarga de pasar al RepositoryJugadores la dirección en la que se encuentra el archivo xml, para que así pueda realizar la extracción de información adecuadamente. Con esto pasamos a crear dos vistas:
public ActionResult Index() {
return View(this.GetRepo().GetJugadores());
}
public ActionResult DetallesJugador(int idjugador) {
ViewBag.Mensaje = TempData["MENSAJE"];
return View(this.GetRepo().BuscarJugador(idjugador));
}–Index, es la vista encargada de recibir la lista de todos los jugadores.
–DetallesJugador, muestra la información detallada de un jugador.
Las vistas de estos son:
Index
@model List<CacheRedisBaloncesto.Models.Jugador>
@{ViewBag.Title = "Index";}
<h2>Index</h2>
@Html.ActionLink("Jugadores favoritos", "JugadoresRedis")
<table class="table table-bordered">
<tr>
<th>Nombre</th>
<th>Equipo</th>
<th></th>
</tr>
@foreach (var item in Model) {
<tr>
<td>@item.Nombre</td>
<td>@item.Equipo</td>
<td>
@Html.ActionLink("Detalles", "DetallesJugador", new { idjugador = item.IdJugador })
</td>
</tr>
}
</table>
DetallesJugador
@model CacheRedisBaloncesto.Models.Jugador
@{ViewBag.Title = "DetallesJugador";}
<h2>DetallesJugador</h2>
<p>@Html.ActionLink("Volver al listado", "Index")</p>
<p>@Html.ActionLink("Favoritos", "AlmacenarFavoritos", new { idjugador = Model.IdJugador }, null)</p>
<h2 style="color:cornflowerblue">@ViewBag.Mensaje</h2>
<div class="container">
<div style="float:left;padding-right:10px">
<h4><b>@Model.Nombre</b></h4>
<hr />
<table>
<tr>
<td>Equipo: <b>@Model.Equipo</b></td>
</tr>
<tr>
<td>Posicion: <b>@Model.Posicion</b></td>
</tr>
</table>
</div>
<div style="float:left;padding-right:10px">
<img src="@Model.Imagen" style="width:250px;height:250px" />
</div>
</div>
Con esto ya hemos hecho que nuestra aplicación extraiga y muestre la información del archivo jugadores.xml. Ahora debemos pasar a las funciones encargadas de almacenar, recoger y eliminar objetos en Azure Redis Cache. Para esto crearemos otro Repository, para así poder tener cada información de forma más ordenada.
Bien, pues creamos una clase llamada RepositoryRedis, en esta clase necesitaremos el siguiente código:
public class RepositoryRedis {
IDatabase bbdd;
public String keyredis;
public RepositoryRedis() {
//Creamos Bbdd en Redis
this.bbdd = AccesoCacheRedis.Connection.GetDatabase();
this.keyredis = "Mvc@Jugador@";
}
public List<Jugador> GetJugadoresCacheRedis() {
List<Jugador> listajugadores = new List<Jugador>();
IDatabase cacheredis = AccesoCacheRedis.Connection.GetDatabase();
//RECUPERAMOS EL PUNTO DE ENTRADA PARA NUESTRA APLICACION EN EL CACHE REDIS
var endpoints = AccesoCacheRedis.Connection.GetEndPoints();
//RECUPERAMOS EL SERVIDOR CON EL PRIMER ENDPOINT Y UNICO DE NUESTRA APP
IServer server = AccesoCacheRedis.Connection.GetServer(endpoints.First());
//RECUPERAMOS TODAS LAS KEYS DE NUESTRO CACHE REDIS
IEnumerable<RedisKey> claves = server.Keys();
if (claves.Count() != 0) {
//TENEMOS CLAVES ALMACENADAS Y RECUPERAMOS CADA UNO DE LOS OBJETOS POR LAS CLAVES
foreach (RedisKey key in claves) {
String jugadorcache = cacheredis.StringGet(key);
//DESERIALIZAMOS EL OBJETO JSON A PRODUCTO
Jugador jugador = JsonConvert.DeserializeObject<Jugador>(jugadorcache);
listajugadores.Add(jugador);
}
return listajugadores;
} else {
return null;
}
}
public void AlmacenarJugador(Jugador jugador) {
String json = JsonConvert.SerializeObject(jugador);
String idjug = this.keyredis + jugador.IdJugador;
this.bbdd.StringSet(idjug, json);
}
public Jugador BuscarJugador(int idjugador) {
String idjug = this.keyredis + idjugador;
RedisValue value = this.bbdd.StringGet(idjug);
if (value.HasValue) {
String json = this.bbdd.StringGet(idjug);
Jugador producto = JsonConvert.DeserializeObject<Jugador>(json);
return producto;
} else {
return null;
}
}
public void EliminarJugadorCache(int idjugador) {
String idjug = this.keyredis + idjugador;
IDatabase cacheredis = AccesoCacheRedis.Connection.GetDatabase();
cacheredis.KeyDelete(idjug);
}
}Los elementos que debemos destacar en esta clase son los siguientes:
–bbdd, es el elemento encargado de crear la base de datos en Azure
–keyredis, es como la “id” con la que almacenamos los objetos, pues así con esta id podremos recuperar también los objetos.
–GetJugadoresCacheRedis, esta función nos devuelve una lista de jugadores, que son todos los que están almacenados en Redis Cache.
–AlmacenarJugador, esta función recibe un objeto Jugador, haciendo así que este sea guardado.
–BuscarJugador, esta función recibe un parámetro id, por el cual busca al jugador con dicha id.
–EliminarJugadorCache, función similar a la anterior, solo que, en este caso al encontrar al jugador almacenado, lo eliminar del Redis Cache.
Una vez hemos realizado las funciones encargadas de administrar el Redis Cache, pasamos al Controller para dar visualización a estas. Lo primero que debemos hacer es realizar la conexión con el nuevo repository que hemos creado, para así utilizar sus funciones.
RepositoryRedis reporedis;
public JugadoresController() {
this.reporedis = new RepositoryRedis();
}Una vez disponemos de la conexión con el RepositoryRedis, realizaremos los siguientes ActionResult que se encargaran de la administración en el apartado del cliente, de los objetos almacenados.
public ActionResult AlmacenarFavoritos(int idjugador) {
//Buscamos si ya tenemos el producto en redis
if (this.reporedis.BuscarJugador(idjugador) != null) {
//El producto existe y nos lo llevamos a detalles con el mensaje
TempData["MENSAJE"] = "El jugador ya existen en la Cache";
return RedirectToAction("DetallesJugador", new { idjugador = idjugador });
} else {
//Recuperamos el producto del Xml
Jugador jugador = this.GetRepo().BuscarJugador(idjugador);
//Almacenamos en Redis Cache
this.reporedis.AlmacenarJugador(jugador);
return RedirectToAction("Index");
}
}
public ActionResult EliminarFavoritos(int idjugador){
this.reporedis.EliminarJugadorCache(idjugador);
return RedirectToAction("JugadoresRedis");
}–AlmacenarFavorito, recibe la id de un jugador y comprueba si este se encuentra ya almacenado. En caso de estar ya almacenado nos lo informa.
–EliminarFavoritos, con la id del jugador llama a la función del repository, y eliminar dicho jugador.
Para finalizar tendremos una vista donde visualizaremos los jugadores almacenados en Azure.
public ActionResult JugadoresRedis() {
return View(this.reporedis.GetJugadoresCacheRedis());
}–JugadoresRedis, simplemente recibe una lista de los jugadores ya almacenados.
@model IEnumerable<CacheRedisBaloncesto.Models.Jugador>
@{ViewBag.Title = "JugadoresRedis";}
<h2>JugadoresRedis</h2>
@Html.ActionLink("Volver a productos", "Index", "Jugadores")
<h2 style="color:blueviolet">@ViewBag.Mensaje</h2>
@if (Model != null)
{
<table class="table table-responsive">
<tr>
<th></th>
<th>Nombre</th>
<th>Equipo</th>
<th>Posicion</th>
<th></th>
</tr>
@foreach (var item in Model)
{
<tr>
<td><img src="@item.Imagen" style="width:150px; height: 150px" /></td>
<td>@item.Nombre</td>
<td>@item.Equipo</td>
<td>@item.Posicion</td>
<td>@Html.ActionLink("Eliminar favoritos", "EliminarFavoritos", new { idjugador = item.IdJugador }, null)</td>
</tr>
}
</table>
}
else
{
<p><b>¿Aún no has añadido ningún jugador a tu lista de favoritos?</b></p>
}
Con esto ya habríamos finalizado todos los pasos para poder llegar a hacer un uso básico de Azure Cache Redis.
Para la realización de este proyecto no creo que puedas llegar a encontrar problema alguno, la situación en la que más problemas puedes llegar a tener es al realizar la cadena de conexión y modificar esos dos parámetros ya comentados, pues esto pueden tener cierta dificultad para encontrar.
Por lo demás nada que añadir, espero haber servido de ayuda, abajo del todo hay un enlace a GitHub donde podréis encontrar este proyecto y el documento que se utilizo para extraer y guardar objetos, el cual espero que os sirva de ayuda.
Autor/a: Tomás Serrano Mata
Curso: Microsoft MCSA Web Applications + Microsoft MCSD App Builder + Xamarin
Centro: Tajamar
Año académico: 2018-2019