[Event] NetConfAR 2018 | Crear tu Startup en Azure con menos de 10 dólares por mes!

Estuvimos con amigos  compañeros de trabajo participando como spaekaer en la gran .NetConfar 2018. Estuve tocando el tema de como crear una StartUp de la mano de Azure con un bajo costo.

¿Cuánta inversión es necesaria para que una empresa pueda tener su infraestructura tecnológica básica para operar? ¿Compro servidores o voy a la nube? ¿Qué servicios de la nube me conviene consumir? En esta charla te vamos a contar cómo se pueden utilizar diversos servicios de Microsoft Azure que son gratuitos o tienen muy bajo costo para lograrlo. Además de contártelo, veremos ejemplos de cómo utilizar estos servicios para poder construir una aplicación completa de punta a punta.

Les dejo los links de la presentación y los videos:

Presentación

Video Entrevista

Video Charla

[Article] .Net Core | User Secrets

En tiempo de desarrollo .Net Core nos brinda esta excelente funcionalidad la cual nos permite guardar configuraciones en nuestro perfil de usuario loca de una forma segura y sencilla. Estás funcionalidad nos ayuda a no subir por error o a no modificar los archivos con información privada en servidores o inclusive en nuestros sistemas de control de código fuente como GitHub, Bitbucket o Team Foundation Service.

Objetivo

En esta entrega estaremos viendo qué es, cómo configurar y utilizar User Secrets. .

Audiencia

Este documento está dirigido a personas que conocen muy poco o nada sobre el tema o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Antiguamente, en nuestras aplicaciones .Net, teníamos la posibilidad de encriptar nuestra información secreta contenida en los archivos web.config. Lo cual a veces lo hacía un poco incómodo al tener que implementar las aplicaciones o guardarlas en nuestros repositorios de código ya que se guardaban información sensible.

Ahora podemos guardar información sensible de la mano User Secrets de forma segura. Entre las cosas que podemos guardar tenemos: cadenas de conexión, claves de API, datos del cliente, datos de cualquier red social o de cualquier aplicación. Todo lo que nosotros consideremos como datos sensible puede ser almacenado sin correr riesgos de exponerla públicamente.

En mi caso me es muy útil cuando subo ejemplos a GitHub. Lo utilizo para subir un ejemplo sin la necesidad de tener que subir en el ejemplo los datos de acceso aun APi que utilizo en Azure o de alguna red social.

Microsoft.Extensions.SecretManager.Tools

Para poder utilizar y tener disponible esta funcionalidad deberemos usar Microsoft.Extensions.SecretManager.Tools.  Secret Manager almacena la información fuera del proyecto y nos permite no solo usar en el proyecto actual, también, nos brinda la posibilidad de usarlo en varios proyectos.

Lo instalaremos desde la consola de los paquetes Nuget en nuestra aplicación.

Una vez instalado hacemos botón derecho sobre nuestro proyecto y seleccionaremos del menú la opción “Manage User Secrets”:

Nos abrirá un archivo del tipo JSON llamado secrets.json. Este archivo guardaran los datos que necesitemos. Este se crea automáticamente y se ubica dentro de una carpeta protegida del sistema. podremos encontrarlo por medio de una estructura  de carpeta similar a esta:

%APPDATA%\Microsoft\UserSecrets\user-secrets-id\secrets.json

Si queremos ver el User-Secrets-Id podemos ubicarlo haciendo click derecho sobre el proyecto y seleccionado la opción “Edit <Nombre del proyecto>.csproj”. Este nos mostrar el archivo de configuración del proyecto con el id dentro:

En nuestro archivo JSON agregaremos un valor con motivo de poder tener información para poder ser consumida más adelante:

{
"TopSecret": "TopSecretValuePasssUserRoot"
}

El siguiente paso es configurarlo en nuestra aplicación Web el servicio. Abriremos el archivo Startup.cs y modificaremos el constructor para que lo tengamos disponible con las siguientes líneas:

Hasta ahora ya tenemos activo nuestro servicio de UserSecrets, agregamos un valor en nuestro archivo secrets.json y configuramos en el constructor para poder acceder. Ahora vamos a consumir el valor desde nuestro archivo. Iremos al HomeController.cs e inyectamos en constructor IConfiguration para tener disponible la consulta del valor:

Por último, Lo ejecutaremos y comprobaremos si está recuperando el error correctamente:

Conclusión

En este post hemos visto  que es, como configurarlo y cómo utilizar UserSecrets. El uso de esta funcionalidad no brinda una gran posibilidad de no estar obligados o por error a subir información confidencial de nuestras cuentas de redes sociales, conexión a base de datos o cualquier información sensible que consideremos.

[HowTo] VS Code | Crear una WebApi con Asp.Net Core en Linux

Como comente en post anterior Microsoft está entrando fuertemente al mundo OpenSource. Por esta razon hoy podemos disfrutar de Asp.Net Core en la plataforma Linux, en mi caso KUbuntu, junto a algunas herramientas muy poderosas com VS Code.

Objetivo

El objetivo de esta publicación tiene un tutorial de como debemos preparar nuestro linux para hacer uso de Asp.Net junto a una aplicacion del tipo WebApi que usaremos en post futuros.

Audiencia

Este documento está dirigido a personas que conocen muy poco o nada sobre el tema o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Para empezar lo que haremos es instalar Net Core es nuestro linux. Lo haré sobre mi distribución preferida que es KUbuntu. Primero necesitamos instalar las llaves de producto y actualizar el listado de paquetes en nuestra distribución linux. Abriremos una consola y ejecutamos los siguiente comandos estos 4 comandos en este orden:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor &amp;amp;amp;amp;amp;amp;amp;gt; microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-zesty-prod zesty main" &amp;amp;amp;amp;amp;amp;amp;gt; /etc/apt/sources.list.d/dotnetdev.list'
sudo apt-get update

 

Ya ejecutado todo estamos listos para instalar:

sudo apt-get install dotnet-sdk-2.0.0

Una vez que instalamos todo y configurado estamos listso. Vamos a crear nuestra primera aplicación en linux. Crearemos una carpeta y ejecutaremos el comando dotnet que nos ayuda a crear la plantilla:

mkdir MvcMyApp
cd MvcMyApp
dotnet new mvc

Ahora podemos abrir desde VS Code que instalamos en un post anterior. Con Solo escribir “code .” se abrirar el VS Code en la carpeta donde estamos parados. Ahora necesitaremos instalar VS Code C# extensión. Lo haremos desde el icono de VS Code, lo buscaremos y lo instalaremos.

Luego de instalarlo recargamos la ventana y comenzará a instalarse algunos componentes necesarios que nos permitirá usar la depuración en VS Code.

Ahora solo nos queda presionar F5 y guala!

 

Una WebApi para ejemplos

Lo que haremos ahora es crear una WebApi Rest que la usaremo en futuros ejemplos en un el tutorial de TypeScript. Vamos a necesitar tener instalado:

  • DB Browser for Sqlite (podemos instalarlos desde el gestor de software que viene con KUbuntu.
  • Postman (podemos descargarlo desde aqui https://www.getpostman.com/)

Empezaremos con crear una carpeta DemoApi y dentro ejecutaremos los comandos de creación y lo abriremos, solo hay que seguir los siguientes comando en orden:

mkdir DemoService
cd DemoService
dotnet new webapi
code .

Nuevamente nos aparecerán los warning a los que debemos darle yes.

Crearemos la base de datos con Sql DB Browser dentro de una carpeta data. La base de Datos la llamaremos DBDemoServices y corremos el script que dejare en el github dentro de la carpeta data se llama base.txt. Este script creará 2 tablas e insertara datos para hacer el demo.

En nuestro servicio usaremos Entity Framework Core como herramienta de acceso a datos. No ayudará con nuestra base de datos Sqlite. Agregaremos las siguientes lineas en nuestro archivo DemoService.csproj:

&lt;PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.0.0" /&gt;
&lt;PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.0"/&gt;

Desde la consola ejecutaremos dotnet restore para actualizar nuestros paquetes:

Comenzaremos creando nuestros modelos y nuestro DBContext. Crearemos 3 archivos, Customer.cs, CustomerType y DemoServiceContext.cs. Todos dentro de una carpeta Models con la siguiente clases dentro:

Customer.cs

using System;
using System.Collections.Generic;

namespace DemoService.Models
{
public partial class Customers
{
public int CustomerId { get; set; }
public string FirstName { get; set; }
public string MiddleName { get; set; }
public string SurName { get; set; }
public string EmailAddress { get; set; }
public int? CustomerTypeId { get; set; }
public string Notes { get; set; }

public virtual CustomersTypes CustomerType { get; set; }
}
}

CustomerType.cs

using System;
using System.Collections.Generic;

namespace DemoService.Models
{
public partial class CustomersTypes
{

public CustomersTypes()
{
Customers = new HashSet&amp;amp;amp;amp;amp;amp;amp;lt;Customers&amp;amp;amp;amp;amp;amp;amp;gt;();
}

public int CustomerTypeId { get; set; }
public string Description { get; set; }

public virtual ICollection&amp;amp;amp;amp;amp;amp;amp;lt;Customers&amp;amp;amp;amp;amp;amp;amp;gt; Customers { get; set; }

}

}

DemoServiceContext.Typecs

using Microsoft.EntityFrameworkCore;
using DemoService.Models;

namespace DemoService.Models
{
public class DemoDBContext : DbContext
{
public DemoDBContext(DbContextOptions&lt;DemoDBContext&gt; options)
: base(options)
{
}
public virtual DbSet&lt;Customers&gt; Customers { get; set; }
public virtual DbSet&lt;CustomersTypes&gt; CustomersTypes{ get; set; }

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlite("Filename=BDemoSevice.db;");
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity&lt;Customers&gt;(entity =&gt;
{
entity.HasKey(e =&gt; e.CustomerId)
.HasName("PK_Customers");

entity.Property(e =&gt; e.EmailAddress).HasColumnType("varchar(150)");

entity.Property(e =&gt; e.FirstName).HasColumnType("varchar(50)");

entity.Property(e =&gt; e.MiddleName).HasColumnType("varchar(50)");

entity.Property(e =&gt; e.Notes).HasColumnType("varchar(5000)");

entity.Property(e =&gt; e.SurName).HasColumnType("varchar(50)");

entity.HasOne(d =&gt; d.CustomerType)
.WithMany(p =&gt; p.Customers)
.HasForeignKey(d =&gt; d.CustomerTypeId)
.HasConstraintName("FK_Customers_CustomersTypes");
});

modelBuilder.Entity&lt;CustomersTypes&gt;(entity =&gt;
{
entity.HasKey(e =&gt; e.CustomerTypeId)
.HasName("PK_CustomersTypes");

entity.Property(e =&gt; e.CustomerTypeId).ValueGeneratedNever();

entity.Property(e =&gt; e.Description).HasColumnType("varchar(50)");
});
}

}
}

Debemos agregar en nuestro archivo Startup.cs la inyección de nuestra base de datos.

public void ConfigureServices(IServiceCollection services){
services.AddMvc();
services.AddDbContext&amp;amp;amp;amp;amp;amp;amp;lt;DemoDBContext&amp;amp;amp;amp;amp;amp;amp;gt;();
}

Ahora que tenemos todo configurado crearemos dentro de la carpeta Controllers un archivo llamado customers.cs donde tendremos nuestra api:

CustomersControllers.cs

using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using DemoService.Models;
using System.Linq;

namespace DemoService.Controllers
{
[Route("api/[controller]")]
public class CustomersController : Controller
{
private readonly DemoDBContext _context;

public CustomersController(DemoDBContext context)
{
_context = context;
}

[HttpGet]
public IEnumerable&lt;Customers&gt; GetAll()
{
return _context.Customers.ToList();
}

}
}

Para comprobar que funciona correctamente ejecutaremos la aplicación presionando F5 y lo invocamos con el Postman:

Bien está funcionando correctamente. Agregamos los métodos de crear, editar y eliminar y también agregaremos el CustomersTypesController.cs y un modelo que será ModeCustomerPage.cs que será para devolver páginas de Customers.

Models/ViewModelPage.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using DemoService.Models;

namespace DemoService.Models
{
public class ViewModelPage
{
public int CountPages { get; set; }
public int CountCustomers { get; set; }
public int ActualPage { get; set; }
public IList&lt;Customers&gt; customers { get; set; }
}
}

CustomersControllers.cs

using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using DemoService.Models;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;

namespace DemoService.Controllers
{
[Route("api/[controller]")]
public class CustomersController : Controller
{
private readonly DemoDBContext _context;

public CustomersController(DemoDBContext context)
{
_context = context;
}

[HttpGet]
public IEnumerable&lt;Customers&gt; GetCustomers()
{
return _context.Customers;
}

[HttpGet("{id}")]
public async Task&lt;IActionResult&gt; GetCustomers([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

var customers = await _context.Customers.SingleOrDefaultAsync(m =&gt; m.CustomerId == id);

if (customers == null)
{
return NotFound();
}

return Ok(customers);
}

[HttpGet]
[Route("{numberPage}/{perPage}")]
public ViewModelPage GetCustomerPaging(int numberPage, int perPage)
{

int _customersCount = GetCustomers().Count();
int _countPages = (_customersCount / perPage) + ( _customersCount % perPage == 0 ? 0 : 1);

var page = new ViewModelPage();
page.ActualPage = numberPage;
page.CountCustomers = GetCustomers().Count();
page.CountPages = _countPages;
page.customers = GetCustomers().Skip(numberPage * perPage).Take(perPage).ToList();

return page;
}

[HttpPut("{id}")]
public async Task&lt;IActionResult&gt; PutCustomers([FromRoute] int id, [FromBody] Customers customers)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

if (id != customers.CustomerId)
{
return BadRequest();
}

_context.Entry(customers).State = EntityState.Modified;

try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomersExists(id))
{
return NotFound();
}
else
{
throw;
}
}

return NoContent();
}

[HttpPost]
public  IActionResult PostCustomers([FromBody] Customers customers)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

_context.Customers.Add(customers);
_context.SaveChanges();

return CreatedAtAction("GetCustomers", new { id = customers.CustomerId }, customers);
}

[HttpDelete("{id}")]
public async Task&lt;IActionResult&gt; DeleteCustomers([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

var customers = await _context.Customers.SingleOrDefaultAsync(m =&gt; m.CustomerId == id);
if (customers == null)
{
return NotFound();
}

_context.Customers.Remove(customers);
await _context.SaveChangesAsync();

return Ok(customers);
}

private bool CustomersExists(int id)
{
return _context.Customers.Any(e =&gt; e.CustomerId == id);
}

}
}

CustomersTypesControllers.cs


using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using DemoService.Models;

namespace DemoService.Controllers
{

[Route("api/[controller]")]
public class CustomersTypesController : Controller
{
private readonly DemoDBContext _context;

public CustomersTypesController(DemoDBContext context)
{
_context = context;
}

[HttpGet]
public IEnumerable&lt;CustomersTypes&gt; GetCustomersTypes()
{
return _context.CustomersTypes;
}

[HttpGet("{id}")]
public async Task&lt;IActionResult&gt; GetCustomersTypes([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

var customersTypes = await _context.CustomersTypes.SingleOrDefaultAsync(m =&gt; m.CustomerTypeId == id);

if (customersTypes == null)
{
return NotFound();
}

return Ok(customersTypes);
}

[HttpPut("{id}")]
public async Task&lt;IActionResult&gt; PutCustomersTypes([FromRoute] int id, [FromBody] CustomersTypes customersTypes)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

if (id != customersTypes.CustomerTypeId)
{
return BadRequest();
}

_context.Entry(customersTypes).State = EntityState.Modified;

try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomersTypesExists(id))
{
return NotFound();
}
else
{
throw;
}
}

return NoContent();
}

[HttpPost]
public async Task&lt;IActionResult&gt; PostCustomersTypes([FromBody] CustomersTypes customersTypes)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

_context.CustomersTypes.Add(customersTypes);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (CustomersTypesExists(customersTypes.CustomerTypeId))
{
return new StatusCodeResult(StatusCodes.Status409Conflict);
}
else
{
throw;
}
}

return CreatedAtAction("GetCustomersTypes", new { id = customersTypes.CustomerTypeId }, customersTypes);
}

[HttpDelete("{id}")]
public async Task&lt;IActionResult&gt; DeleteCustomersTypes([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

var customersTypes = await _context.CustomersTypes.SingleOrDefaultAsync(m =&gt; m.CustomerTypeId == id);
if (customersTypes == null)
{
return NotFound();
}

_context.CustomersTypes.Remove(customersTypes);
await _context.SaveChangesAsync();

return Ok(customersTypes);
}

private bool CustomersTypesExists(int id)
{
return _context.CustomersTypes.Any(e =&gt; e.CustomerTypeId == id);
}
}
}

Listo nuestra aplicación está completa ahora probaremos un post con el postman.

Conclusión

Hemos instalado y configurado .Net Core y Asp.Net Core en nuestro linux. También hicimos una pequeña base de datos y nos conectamos a ella por medio de WebApi para tener servicio Rest. Estos servicios rest los usaremos en otros post para algunos ejemplo. Pueden descargar el código complete de GitHub desde esta url https://github.com/withoutdebugger/DemoService

 

 

[HowTo] Visual Studio Code | En Linux

Microsoft en estos últimos tiempos está apostando al OpenSource. Una de las cosas que ha impulsado es el uso de sus herramientas en este caso el editor liviano pero extremadamente potente VS Code.

Objetivo

El objetivo de esta publicación tiene un tutorial de como podemos instalar Visual Studio Code en linux.

Audiencia

Este documento está dirigido a personas que conocen muy poco o nada sobre el tema o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Visual Studio Code es un editor de código ligero y muy potente el cual podemos ejecutarlo en cualquier plataforma como Windows, MacOs o Linux. Viene con soporte Intellisense y para varios lenguajes de forma nativa. También podemos utilizar controladores de código fuente como Git o TFS. Por último, la característica que más me gusta, es totalmente extensible. Gracias a esto última característica tenemos una gran cantidad de plugin que podemos instalar para cualquier lenguaje que utilicemos.

Yo he elegido, solo por gusto personal, la distribución Kubuntu. No por nada en particular solo me gusta mas KDE. Lo primero que debemos hacer es descargar el paquete desde la página con la extensión .deb. Pueden hacerlo desde este link  https://code.visualstudio.com/

Una vez que lo tenemos descargado debemos abrir una consola, ir a la carpeta donde descargamos los archivos. En KUbuntu tenemos la posibilidad de instalarlo por medio de QApt:

Y listo! tenemos nuestro VS Code instalado

Para los más audaces podemos instalarlo por medio de consola completamente. Comencemos:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor &amp;gt; microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/vscode stable main" &amp;gt; /etc/apt/sources.list.d/vscode.list'

“Nota: puede ser que no tengamos curl instalado por esta razón primero deberemos instalarlo con el siguiente comando apt-get install curl“

Si no hemos tenido ningún problema, el siguiente paso es actualizar nuestro repositorio de paquetes para esto usaremos el siguiente comando

sudo apt-get update

Por último, lo que nos queda es instalar el VS Code desde el repositorio.

sudo apt-get install code

Ya lo tenemos instalado y listo para comenzar disfrutar de esta gran herramienta.

Conclusión

Hemos instalado VS Code en nuestro linux de una forma muy sencilla. En próximos post veremos como hacer una aplicación .Net.

[Article] Azure | Content Delivery Network (CDN)

Hoy quiero tocar el tema de CDN específicamente Azure Content Delivery Network. Esta herramienta nos ofrece una solución global para tener contenido disponible usando un ancho de banda de gran velocidad. En esta red podemos almacenar objetos en cache publicos tales como archivos, aplicaciones, maquinas virtuales o cualquier objeto que pueda almacenarse en vía http o https.

Objetivo

El objetivo de esta publicación es tocar las posibles utilizaciones y alcance del manejo CDN para mejorar la performance y la escalabilidad en nuestras aplicaciones Asp.Net Core.

Audiencia

Este documento está dirigido a desarrolloradores que quieren conocer Asp.Net core y el uso de Azure CDN o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Usualmente CDN lo utilizamos para entregar contenido estático, como imágenes, archivos javascript, archivos de estilos css, etc. Aunque en su gran mayoría se usa para esto, también, podemos utilizar para brindar contenido dinámico almacenando su parametrización y devolviendo el mismo resultado.

Una de las principales ventajas del uso es que posee una latencia muy pequeña lo cual hace que se pueda entregar contenido extremadamente rápido sin estar atado a una ubicación geográfica o bien brindando lo más cerca posible del usuario que la solicita.

 

Usar CDN no ayuda a reducir la carga de la aplicación ya que liberamos a los servidores de procesamiento innecesario al entregar el contenido. Esto aumenta el rendimiento y reduce el costo del consumo de red como también aumentando la disponibilidad.

Veamos algunos casos típicos donde podemos usar CDN:

  • Recursos Estáticos: Nuestros sitios web contienen una gran cantidad de contenidos estáticos como imágenes, hojas de estilo, documentos, archivos, páginas web completas o parciales o cualquier contenido que no necesita ser procesado por el servidor.
  • Contenido Estático para dispositivos móviles: Por medio de servicio web se puede proporcionar datos estáticos a este tipo de clientes.
  • Media y Video: Podemos transferir videos pequeños. El gran beneficio es que baja mucha la latencia y aumenta la disponibilidad de este tipo de contenido. Algo para tener en cuenta es que Azure Media Services puede ser integrado con Azure CDN para entregar contenido.
  • Aumento de Demanda: podemos evitar que el aumentar la demanda no aumente nuestros costos de consumo. Por ejemplo, si nuestra aplicación lanza una nueva versión, aumentará la demanda de nuestros archivos y contenido para las nuevas características.

Ahora bien, qué debemos tener en cuenta para el uso o implementación:

  • Debemos tenerlo en cuenta durante nuestro proceso de desarrollo e implementación de contenido estático y recursos de nuestras aplicaciones.
  • Debemos considerar que nuestro contenido será actualizado, por esto, debe estar versionado.
  • Es difícil realizar pruebas locales o probar aplicaciones locales.
  • El contenido público es enviado desde dominios diferentes lo cual puede afectar a los resultado SEO.
  • Podemos encontrarnos con entornos donde no podamos consumir recursos directamente desde el CDN. Para esto es necesario hacer una implementación especial.
  • Si la red es privada, como una empresa, tal vez no sea una buena opción por restricciones de seguridad de la misma red.}

Usar CDN es una buena práctica para minimizar la carga, maximizar la disponibilidad y rendimiento de nuestras aplicaciones. Es altamente recomendable para implementar en nuestras aplicaciones web. Veamos algunas estrategias:

Entrega

  • CDN solamente necesita un endpoint HTTP o HTTPS la cual será utilizada para acceder y para almacenar el contenido.
  • Debemos recordar que el Blob al cual esté direccionado debe ser público.
  • Si nuestro lo seteamos como root en una WebApp todo el sitio quedará disponible por CDN.
  • Cuando las fuentes son dinámicas, podemos utilizar parametros via QueryString como llaves para almacenar en caché el contenido de este tipo.
  • Debemos recordar que los recursos del tipo blobs son sensibles a mayusculas y minusculas.

Despliegue

  • El contenido puede necesitar ser desplegado inmediatamente. Debemos considerar que será necesario un mecanismo de control de versiones para poder entregar las el contenido correctamente.
  • La comprensión, unión y minificación de archivos son técnicas utilizadas para reducir el tiempo de carga de los clientes y son compatibles con CDN.
  • Al utilizar la compresión de contenido será enviado en un formato zip o gzip. Por default Azure comprimira el contenido si el procesador se encuentra menos de un 50% de consumo.

Enrutamiento y control de versiones

  • Si necesitamos mantener control de versiones podemos crear un nuevo CDN y conservar el antiguo para versiones anteriores de nuestra aplicación.
  • La implementación de nuevas versiones de contenido estático será necesario tener en cuenta si fueron almacenados en el caché del CDN.
  • Podemos restringir acceso por país. Azure CDN nos permite filtrar contenido por origen de la petición y restringir la entrega del contenido.

Control de Caché

  • Debemos considerar el almacenamiento del caché en el sistema. Podemos configurar propiedades de caché desde el CDN y para el cliente podemos configurar los encabezados HTTP.
  • Podemos purgar el caché eliminandolos manualmente, convertir el blob en privado. Debemos tener en cuenta que los archivos solo serán eliminados cuando el tiempo de vida expire realmente si no se especificado un tiempo de cache.
  • En las aplicaciones web podemos establecer el almacenamiento de cache y su caducidad mediante el elemento clientCache del namespace system.webServer / staticContent en el archivo web.config.
  • Si el contenido es dinámico no debemos olvidar setear la propiedad Cache.SetExpires en cada página.

Seguridad

  • En el CDN puede entregar contenido a través de HTTPS utilizando certificados proporcionado por el mismo. También estará disponible en HTTP ya que no es posible bloquear los elementos por este canal.
  • Podemos tener algunos inconvenientes al usar peticiones AJAX debido a que se hace uso del objeto XMLHttpRequest cuando son solicitados datos, imágenes o fuentes de un dominio diferente. La gran mayoría de los navegadores evitan el consumo de objetos cruzados (CORS) si el servidor no está configurado correctamente.

Dominios personalizados

  • Podemos usar dominios personalizados y utilizarlo para acceder a recursos a través de CDN.
  • Podemos utilizar subdominios utilizando registros CNAME en nuestros CDN. Recordemos que si usamos este método no podremos usar SSL ya que el CDN utiliza sus propios certificados.

Tips para SEO

  • Debemos incluir el encabezado REL en cada una de las paginas o los recursos.
  • Utilizar un subdominio CNAME para acceder a los recursos.}
  • Tener en cuenta que la dirección IP del CDN puede ser diferente del pais donde se encuentra su aplicación.
  • Mantener la misma estructura si estamos usando almacenamiento Blob Azure

Supervisión y registro

Debemos agregar en nuestra estrategia de construcción de aplicaciones el planeamiento para implementación de CDN para poder detectar y medir fallas o problemas de latencia. Desde el portal de Azure podemos encontrar un panel de administración.

Demos Considerar:

  • Ancho de banda
  • Datos transferidos
  • Hits
  • Estado del caché
  • Cache Hit ratio
  • Solicitudes desde IPV4 / 6

Costos

Algo para tener muy presente es que se cobra por transferencia de información saliente desde nuestro endpoint CDN. Debemos incluir el costo de almacenamiento de recursos que se alojan activamente y sus transacciones. Debemos balancear los tiempo de expiración de caché, no debe ser muy largos para mantener un caché actualizado como no deben ser muy cortos para aumentar los costos.

Agrupamiento y minificación

Una excelente práctica es la agrupación  y la minificación de recursos. Esta práctica reduce notoriamente los tiempos de descarga debido a su reducción en tamaño.

Tenemos varias formas de manejar este tipo de prácticas. Podemos hacerlo desde .Net MVC como también con algunas herramientas de NodeJS. Mi recomendación es ver WebPack, una herramienta muy popular dedica a este tipo de funciones.

Conclusión

CDN posee un gran soporte para la utilización de caché tanto en entrega de contenido estático o contenido dinámico. Podemos aprovechar esta funcionalidad para aumentar el rendimiento y la escalabilidad de nuestras aplicaciones. En futuros artículos veremos como usar Azure CDN.

[Article] Asp.Net Core | Globalización y Localización

En estos últimos días estuve analizando una aplicación para convertirla a soporte en múltiples lenguajes. Asp.Net Core nos brinda una gran cantidad servicios en su middleware. Entre ellos tenemos disponibles para manejar la globalización y la localización de una manera muy simple.

Objetivo

El objetivo de esta publicación es tocar las posibles utilizaciones y alcance del manejo de globalización y localización como también que son y para qué pueden sernos útiles.

Audiencia

Este document o está dirigido a desarrolladores que quieren conocer Asp.Net Core o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Comencemos aclarando algunos conceptos:

  • Globalización (Globalization) es el proceso por el cual se debe diseñar una aplicación para que pueda responder a diferentes culturas. Esta agrega soporte para entrada de información, también su salida o visualizaciones definida para cierto lenguaje o para un área geográfica específica.
  • La localización (Localization) es la adaptación de una aplicación globalizada para una cultura particular cultura.

Para tener disponibles estas caracteristicas deberemos hacer uso de 2 interfaces IStringLocalizar y IStringLocalizar<T>. Estas 2 últimas hacen uso de las clases ResourceManager and ResourceReader que proveerán la información específica que será recuperada de los archivos de recursos.

Algo para destacar es que no es necesario tener los archivos de recursos disponibles. Si invocamos un valor y no existe un archivo de recurso o valor devolverá el nombre del parámetro. Esto puede utilizarse como idioma por default.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Localization;

namespace AspNetCoreGloLoc.Controllers
{
[Route("api/[controller]")]
public class StringTextController : Controller
{
private readonly IStringLocalizer&lt;StringTextController&gt; _localizer;

public StringTextController(IStringLocalizer&lt;StringTextController&gt; localizer)
{
_localizer = localizer;
}
[HttpGet]
public string Get()
{
return _localizer["Title"];
}
}
}

Si necesitamos implementar globalización y localización dentro de código con html una buena opción es usar las interfaces IHtmlLocalizar y IHtmlLocalizar<T>. Debemos hacer uso de los siguientes namespaces Microsoft.AspNetCore.Localization y Microsoft.AspNetCore.Mvc.Localization. Usualmente usamos siempre texto simple antes que html específico.


using System;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Localization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Localization;&lt;/pre&gt;
namespace Localization.StarterWeb.Controllers
{
public class BookController : Controller
{
private readonly IHtmlLocalizer&lt;BookController&gt; _localizer;

public BookController(IHtmlLocalizer&lt;BookController&gt; localizer)
{
_localizer = localizer;
}

public IActionResult Hello(string name)
{
ViewData["Message"] = _localizer["&lt;b&gt;Hello&lt;/b&gt;&lt;i&gt; {0}&lt;/i&gt;", name];

return View();
}
Una opción interesante es la posibilidad de particionar la localización por controlador, área o algún tipo de contenedor. Veamos cómo podemos usar ShareResource para esto.
namespace Localization.StarterWeb
{
public class SharedResource
{
}
}

Podemos usar Startup del proyecto y agregarlo al contenedor global veamos el siguiente controlador de ejemplo:

&lt;/pre&gt;
public class InfoController : Controller
{
private readonly IStringLocalizer&lt;InfoController&gt; _localizer;
private readonly IStringLocalizer&lt;SharedResource&gt; _sharedLocalizer;

public InfoController(IStringLocalizer&lt;InfoController&gt; localizer,
IStringLocalizer&lt;SharedResource&gt; sharedLocalizer)
{
_localizer = localizer;
_sharedLocalizer = sharedLocalizer;
}

public string TestLoc()
{
string msg = "Shared resx: " + _sharedLocalizer["Hello!"] +
" Info resx " + _localizer["Hello!"];
return msg;
}

Para una vista podemos usar IViewLocalizer. ViewLocalizer implementa la interface anterior y busca en los archivos de recursos dependiendo el path de la vista.

@using Microsoft.AspNetCore.Mvc.Localization

@inject IViewLocalizer Localizer

@{
ViewData["Title"] = Localizer["About"];
}
&lt;h2&gt;@ViewData["Title"].&lt;/h2&gt;
&lt;h3&gt;@ViewData["Message"]&lt;/h3&gt;

&lt;p&gt;@Localizer["Use this area to provide additional information."]&lt;/p&gt;
&lt;pre&gt;

Importane!:

  • Es necesario usar el paquete nuget “Localization.AspNetCore.TagHelpers”.
  • Generalmente usamos una sola localizacion para texto y no HTML.

Otra opción que utilizamos mucho puede ser por medio de DataAnnotations.

public class RegisterViewModel
{
[Required(ErrorMessage = "The Email field is required.")]
[EmailAddress(ErrorMessage = "The Email field is not a valid e-mail address.")]
[Display(Name = "Email")]
public string Email { get; set; }

[Required(ErrorMessage = "The Password field is required.")]
[StringLength(8, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 6)]
[DataType(DataType.Password)]
[Display(Name = "Password")]
public string Password { get; set; }

[DataType(DataType.Password)]
[Display(Name = "Confirm password")]
[Compare("Password", ErrorMessage = "The password and confirmation password do not match.")]
public string ConfirmPassword { get; set; }
}

Conclusión

Asp.Net Core posee un de características las cuales nosotros como desarrolladores podemos sacarle un muy buen provecho a la localización y globalización. En próximo post hablaremos de la utilización de archivos de recursos para lograr el mismo objetivo.

[Article] Asp.Net Core | Manejo errores

Algo muy importante que deberíamos tener en cuenta en el desarrollo de nuestras aplicaciones es un correcto manejo de excepción. En varios de nuestros clientes notamos que no hacen uso de una forma correcta o directamente no es tenido en cuenta. Al ocurrir algún error dentro de una aplicación Asp.Net nos permite manejalo de varias formas de una manera simple y rápida.

Objetivo

El objetivo de esta publicación es tocar las posibles utilizaciones y alcance del manejo de errores propuesto por Asp.Net Core.

Audiencia

Este documento está dirigido a desarrolloradores que deseen conocer Asp.Net core o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Comencemos enumerando las diferentes tipos de excepciones, configuraciones y opciones que podemos utilizar:

  • Página de excepción para desarrollo.
  • Configurar excepciones personalizadas.
  • Configurando código de estado para las páginas.
  • Manejando código de excepciones.
  • Manejando código de excepciones en el servidor.
  • Manejo de excepción en el inicio de aplicación.
  • Manejo de excepciones en Asp.Net MVC.

Página de excepciones para desarrollo

La configuración por defaults de la página de errores tal vez es poca. Por este motivos, para obtener una mayor cantidad de información podemos instalar el paquete Nuget Microsoft.AspNetCore.Diagnostics. Luego de instalar el paquete debemos hacer la inyección correspondiente en el método Configure que se encuentra en el archivo startup.cs de la siguiente manera.


public void Configure(IApplicationBuilder app, IHostingEnvironment env,
ILoggerFactory loggerFactory){
loggerFactory.AddConsole();
env.EnvironmentName = EnvironmentName.Production;

if (env.IsDevelopment()){
app.UseDeveloperExceptionPage();
}else{
app.UseExceptionHandler("/error");
}
}

  • Recordemos que esto solo debe estar activo cuando la aplicación esté corriendo en un entorno de desarrollo.

Para ver la página  de excepción debemos correr la aplicación seteado en entorno de desarrollo y debemos agregar ?throw=true en la url. Podemos que la página incluye algunos tabs muy interesantes que contienen la información de la excepción y el request que hicimos. La primera solapa es Stack:

La solapa Query muestra los parámetros pasados por Query String si los hay.

La siguiente solapa es Cookies. Si hay cookies en el request van a aparecer en esta solapa.

Por último, tenemos la solapa de Headers donde podemos ver todos los encabezados enviados en el Request.

Configurar excepciones personalizadas

Cuando no estamos trabajando en un entorno de desarrollo es conveniente configurar un manejador especial.


public void Configure(IApplicationBuilder app, IHostingEnvironment env,
ILoggerFactory loggerFactory){
loggerFactory.AddConsole();
env.EnvironmentName = EnvironmentName.Production;
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/error");
}
}

En Asp.Net MVC no tenemos un decorador de errores para que ejecute una acción dependiendo de un método http. Para solucionar esto debemos tener un Action que sea ruteado a el como podemos ver en el siguiente código:

[Route("/Error")]
public IActionResult Index()
{
// Handle error here
}

Configurando código de estado para las páginas

Nuestra aplicación, por default, no muestra ningun codigo de estado para un código de estado de HTTP como podría ser el error 500(Internal Server Error) o el 404 (Not Found). Podemos configurar StatusCodePagesMiddleware en el método Configure en el archivo startup.cs

app.UseStatusCodePages();

Este middleware agregara un texto simple como podemos ver en la captura

app.UseStatusCodePages() puede soportar varios tipos de métodos. Alguno pueden ser expresiones del tipo lambda o tipos de contenido o formato de textos como podemos ver en los siguientes codigos:


app.UseStatusCodePages(async context =&gt;
{
context.HttpContext.Response.ContentType = "text/plain";
await context.HttpContext.Response.WriteAsync(
"Status code page, status code: " +
context.HttpContext.Response.StatusCode);
});

app.UseStatusCodePages("text/plain", "Status code page, status code: {0}");

En otros casos podemos redireccionar directamente a algún método que deseamos. por ejemplo, podemos devolver el error 302 al cliente pero también podemos redireccionarlo a un dirección url.

app.UseStatusCodePagesWithRedirects("/error/{0}");
app.UseStatusCodePagesWithReExecute("/error/{0}");

Si necesitamos desactivarlo por algún motivo simplemente debemos usar el siguiente código:

var statusCodePagesFeature = context.Features.Get&lt;IStatusCodePagesFeature&gt;();

if (statusCodePagesFeature != null)
{
statusCodePagesFeature.Enabled = false;
}

Manejando código de excepciones.

A menudo es una buena idea para las páginas de error en producción para constan de contenido puramente estática. Hay que tener en cuenta que una vez enviado los encabezados en el response es posible cambiar el estado de la respuesta como tampoco ejecutar otra página de excepción. El response debe ser completado o la conexión abortada.

Manejando código de excepciones en el servidor.

Recordemos que además de manejar las excepciones, en el servidor donde se encuentra alojada la aplicación, realizara alguna gestión sobre esa excepción. Algunos puntos para tener en cuenta son: Si el servidor detecta un error 500 antes de que se envíe al cliente se enviará un error sin contenido. Si se detecta una excepción después de que los cabeceros se han enviado, se cerrara la conexión, por último, las solicitudes que no son manejadas por la aplicación serán manejadas por los servidores. Cualquier configuración que hagamos en el manejo de excepciones no modificarán el comportamiento del servidor.

Manejo de excepción en el inicio de aplicación

Todas las configuraciones y situaciones anteriores ocurren durante el ciclo de vida de la aplicación. En caso de ocurrir un error durante el inicio de la aplicación se disparará una excepción a nivel servidor.

Manejo de excepciones en Asp.Net MVC.

Asp.Ne MVC  tiene algunas opciones mas para poder capturar errores como configurar excepción en los llamados filtros (filter) y validaciones en los modelos.

Exception Filters

Un filtro puede ser configurado de forma global o sobre un controller o  action basado en MVC. Los filtros pueden capturar una excepción que no haya sido configurada con anterior mientras ocurre la ejecución de un controlado o acción. Inclusive en un filtro.

Handling Model  State Errors

El Model Validation se ejecuta cuando el controlador y el action son invocados. Es posible invocarlo con el método ModelState.IsValid para verificar si el modelo está correct.

Conclusión

un buen manejo de errores puede evitarnos un dolor de cabeza muy grande cuando nuestra aplicación está fallando y no sabemos cuál es la causa.

[Event] Global Azure BootCamp 2018 | Azure B2C: servicio de identidad ágil para tus desarrollos.

El día de ayer estuvimos presentando Global Azure Bootcamp 2018 Buenos Aires el tema  Azure B2C. Les dejo los link de la presentación y los el video.

El día de ayer estuve presentando Global Azure Bootcamp 2017 Buenos Aires el tema  Azure B2C. Les dejo los link de la presentación y los el video.

Presentación

Video Charla

Video Entrevista

[Article] Azure | Integrando Azure Search en un Website

En en el artículos anterior (ir al articulo anterior) estuvimos viendo qué es Azure Search y como podemos configurarlo para comenzar a utilizarlo. En este artículo veremos cómo integrarlo en una Aplicación Web por medio del SDK que nos brindan.

Objetivo

En esta entrega estaremos integrando Azure Search en una Aplicación Web. Veremos sus características y funcionalidades plasmadas en un WebSite. El código del proyecto podrán descargo desde GitHub desde esta dirección

https://github.com/withoutdebugger/DemoAzureSearchWODv1

Audiencia

Este documento está dirigido a personas que conocen muy poco o nada sobre el tema o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Antes que nada necesitaremos el SDK. El SDK posee un conjunto de librerías de cliente las cuales las utilizaremos para manejar los índices, los datasource, indexadores, subir documentos, ejecutar queries y todo lo que necesitemos.

Las librerías principales son:

  • Azure.Search
  • Search.Models

Estas librerías tienen definidas algunas clases principales como Index, Field y Document como también algunas operaciones como Indexes.Create o Documents.Search asociadas a SearchServiceClient y SerachIndeCliente. Están agrupadas de una forma lógica para una mejor compresión.

Una vez listo el SDK en nuestra aplicación necesitaremos los ApiKey que Azure. Esta llave nos dará acceso al servicio y a base de búsqueda. La guardaremos en nuestra configuración de connections strings.

Para obtenerlos debemos ingresar al portal de Azure. Seleccionamos nuestro servicio de búsqueda -> opción claves:

Estas claves la usaremos dentro de nuestro archivo appsettings.json para tenerlas disponibles y consultarlas en el momento de consumir el servicio.

{
"AzureSearch": {
"SearchServiceName": "{nombre del servicio}",
"SearchServiceAdminApiKey": "{apikey}",
"SearchServiceQueryApiKey": "{apikey} "
},

...

}

Nuestra aplicación es una aplicacion ASP.Net Core MVC junto a una Web APi que será consumida por medio de JQuery. No voy a entrar en detalle de la aplicación MVC pero si en el servicio de búsqueda.

Tendremos el Home Controller que solamente nos devolverá la página inicial donde se encontrarán nuestros métodos en JQuery que consumirán los servicios de búsqueda.

Crearemos una Web API que se llamara Search. Será un controller llamado SearchController. Este recibirá en su constructor la clase IConfiguration para tener disponible el servicio de Azure Search.

{
searchServiceName = _configuration["AzureSearch:SearchServiceName"];
queryApiKey = _configuration["AzureSearch:SearchServiceQueryApiKey"];
indexClient = new SearchIndexClient(searchServiceName, "realestate-us-sample", new SearchCredentials(queryApiKey));
}

Nuestro método principal Get será el encargado de recibir las consultas desde el cliente. En esta primera versión filtra por texto, facets, tag y manejara la paginación. También tendremos algunos métodos privados que nos ayudaran a armar la consulta final.

Modelo Hotel

Este modelo es en el cual se transformara el resultado de Azure Search en nuestra aplicación.

public partial class Hotel
{
[System.ComponentModel.DataAnnotations.Key]
public string listingId { get; set; }
public string description { get; set; }
public string description_es { get; set; }
public string number { get; set; }
public string street { get; set; }
public string city { get; set; }
public string countryCode { get; set; }
public string postCode { get; set; }
public string thumbnail { get; set; }
public string status { get; set; }
public string[] tags { get; set; }
}

Get Method

El método principal recibirá los parámetros de consulta. Dentro podemos ver que tenemos los métodos privados CreateFilterFacets, CreateFilterTags, CreateParameter.

[HttpGet]
public DocumentSearchResul&lt;Hotel&gt; Get(string searchtext = "", string cityFacet = "", string typeFacet = "", string tags = "", string orderby = "", string derbydirection "desc", int actualPage = 1)
{
//Filter
string filter = CreateFilter(cityFacet, typeFacet);

//Filter Tags
IList&lt;ScoringParameter&gt; filterTags = CreatedFilterTags(tags);

//Parameters
SearchParameters sp = CreateParameter(10, filter, orderBy, filterTags, actualPage);

//Search
var result = indexClient.Documents.Search&lt;Hotel&gt;(searchtext, sp);
return result;
}

CreateFilterFacets

 Este método es el encargado de crear los filtros para los facets de City y Type. Como podemos ver en el método, el resultado un string que acompañará a la consulta. Azure Index utiliza una estructura OData formar las consultas. Por ejemplo, en el string el comando podemos ver el comando eq que significa igual. Podemos ver la lista completa de comando desde este link:

https://docs.microsoft.com/en-us/rest/api/searchservice/odata-expression-syntax-for-azure-search

private string CreateFilterFacets(string cityFacet, string typeFacet) {

string filter = "";

if (cityFacet != null)
{
filter += filter != string.Empty ? " and " : "";
filter += "city eq '" + cityFacet + "'";
}

if (typeFacet != null)
{
filter += filter != string.Empty ? " and " : "";
filter += "type eq '" + typeFacet + "'";
}

return filter;
}

CreateFilterTags

Este método es el encargado de crear una lista de Tags para filtrar. A diferencia del anterior, los tags deben filtrarse por medio de ScoringParameter que hace referencia a un nivel de acierto.

private IList&lt;ScoringParameter&gt; CreateFilterTags(string tags) {

IList&lt;ScoringParameter&gt; _parameterTags = new List&lt;ScoringParameter&gt;();

if (tags == null) { return _parameterTags; }

string[] _listTags = tags.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);

if (_listTags.Count() &amp;gt; 0)
{
_parameterTags.Add(new ScoringParameter("tags", _listTags));
}

return _parameterTags;
}

CreateParameter

Antes de la ejecución final de obtención de resultados debemos armar un SearchParamters. Desde este manejaremos la configuración principal de la consulta como el modo de búsqueda, cuántos tomar por medio de top, el filtro de text, el cálculo para la página, los campos que usaremos, si incluimos el total y los facets que filtraremos. Por último también se agregara tags correspondientes al ScoringParameters.

private SearchParameters CreateParameter(int top, string filter, IList&amp;lt;string&amp;gt; orderby, IList&amp;lt;ScoringParameter&amp;gt; filterTag, int currentPage)
{

SearchParameters searchParameters =
new SearchParameters() {
SearchMode = SearchMode.Any,
Top = 10,
Filter = filter,
Skip = currentPage - 1,
Select = new Lis&lt;String&gt;() { "listingId", "description", "description_es", "number", "street", "city", "countryCode", "postCode", "thumbnail", "status", "tags" },
// Add count
IncludeTotalResultCount = true,
//// Add facets
Facets = new List&lt;String&gt;() { "city", "type", "status", "tags" },
};

searchParameters.OrderBy = orderby;
searchParameters.ScoringParameters = filterTag;

return searchParameters;
}

Ejecución de resultado

Una vez que tenemos todo los objetos armados para nuestra consulta se llamará al siguiente método perteneciente al cliente de Azure Search.

var result = indexClient.Documents.Search&lt;Hotel&gt;(searchtext, sp);

indexClient es del tipo SearchIndexClient el cual es el encargado de realizar finalmente la consulta en nuestro servicio de Azure Search. Podemos ver que le enviaremos nuestra clase Hotel y el se encargara de hacer la transformación.

La aplicación

Finalmente nuestra aplicación se verá visualizará de la siguiente forma luego de una búsqueda:

Podemos filtrar la búsqueda por medio de la selección en cada una de las secciones City, Type y Tags para ajustar nuestros resultados. El encargado de ajustar la búsqueda sera los métodos creados en JQuery.

 

Conclusión

Azure Search es una excelente herramienta para realizar potentes búsquedas. También nos brinda un SDK muy potente para que podamos realizar consultas muy rápidamente y poder así integrar rápidamente en nuestras aplicaciones

Les dejos la aplicación de ejemplo en GitHub para que puedan consultarla:

https://github.com/withoutdebugger/DemoAzureSearchWODv1

También les dejo el link del demo:

http://wodazuresearch.azurewebsites.net/

[Article] Azure | Azure Search

En este artículo hablaremos de Azure Search. Azure Search es una solución que Microsoft nos brinda para poder integrar una excelente experiencia de búsqueda en nuestras aplicaciones móviles, web o cualquier aplicación como empresariales.

Objetivo

En esta entrega veremos qué es Azure Search. También, como configurar nuestra cuenta de Azure Search y un pequeño demo de como utilizarlos en una aplicación web.

Audiencia

Este documento está dirigido a personas que conocen muy poco o nada sobre el tema o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Todos los días, como usuarios, al usar aplicaciones estamos acostumbrados a los métodos de búsqueda rápidos y muy eficientes. Por ejemplo, todos los dias, en algun momento, buscamos en Google o algun motor de búsqueda de nuestra preferencia. Cuando usamos otras aplicaciones buscamos la misma experiencia de búsqueda.

Azure Search nos da la posibilidad de tener la misma experiencia de búsqueda en nuestras aplicaciones. Todo esto es posible gracias que tenemos disponible una gran cantidad de APIs Rest para consumir el servicio, también, un SDK muy completo en .Net. Por último,  dentro del portal de Azure tenemos muchas herramientas para la creación de prototipos, creación y consulta de índices.

Para poder comenzar es necesario una cuenta de Azure. Les dejo el link para poder obtener una cuenta gratuita junto a 200 dolares de crédito para poder probar las capacidades que Azure Search brinda:

Suscribirse

Características de Azure Search

A continuación analizaremos las características funcionales más interesantes, desde mi punto de vista, que podemos usar con Azure Search. Son las siguientes:

Búsqueda de texto completo y analisis de texto

Corresponde a la búsqueda que se basa escribiendo en una caja de texto. Podemos usar operadores lógicos o frases de búsqueda como cualquier buscador de internet.

Integración de datos

Azure Search soporta gran variedad de orígenes de datos. La unica caracteristica que tienen que tener estos datos es que tienen que respetar la estructura de datos del tipo JSON.

No obstante tenemos disponible soporte para Azure SQL Database, Azure Cosmos DB o Azure Blob Storage. En este último podemos tener documentos del tipo Microsoft Office, PDF o Html los cuales pueden ser indexados para búsquedas dentro de documentos.

Análisis Lingüístico

Básicamente, tendremos la capacidad de analizar la busqueda relacionado con una fonética de un lenguaje o alguna expresión regular. Podemos controlar el idioma, los tiempos verbales, género, nombres plurales o singulares o inclusive el manejo de palabras compuestas.

Características de la experiencia del usuario

Entre las características más importantes que podemos brindarles a nuestros usuarios tenemos:

  • Sugerencias de búsqueda: a medida que los usuarios van escribiendo su búsqueda le podemos ir sugerencias mostrando relacionadas con lo ingresado.
  • Navegación por facetas: Es un listado de categorización que podemos usar como filtros. Este tipo de filtro es muy similar a los sitios de compras, como amazon, que en el lado izquierdo tenemos varias opciones agrupadas que al hacer un solo click filtran la búsqueda principal.
  • Resaltado de referencias: podemos aplicarle un formato al resultado, por ejemplo subrayarlo en negrita, indicando que está relacionado con la búsqueda.
  • Ordenación: podemos ofrecer varias forma de ordenar la información obtenida del resultado de búsqueda.
  • Paginación: Como todo buen listado de búsqueda, podemos paginarlo.

Supervisión e informes

Es importante analizar las búsquedas de nuestros usuarios con el objetivo de tener que ajustar nuestro índices para que las posteriores búsquedas sean más efectivo y eficiente. Azure Search registra todas la búsquedas realizadas para posterior análisis. En un post futuro tocaremos este tema con más detalle.

Otras Características

Además de las nombradas, Azure Search tiene las siguientes características:

  • Georeferencia: Filtro por ubicaciones geográficas.
  • Relevancia: Usando perfiles de puntuación podemos darle relevancia a ciertos documentos.
  • Herramientos de prototipos e Inspección: configurar indexadores, crear índices, consulta de un índice particular, etc.

Manos a la Obra

Una vez que tenemos nuestra cuenta Azure, es muy sencillo crear una cuenta de Azure Search. Debemos seguir los siguiente pasos:

1. Ingresar al portal y buscar en el MarketPlace “Búsqueda de Azure”, lo seleccionamos y presionamos crear.

2. Completamos los datos que nos solicita el formulario. En mi caso la url sera testwod pero pueden seleccionar un nombre que ustedes deseen. En el plan de tarifa, para motivos de este demo, usaremos la tarifa gratis.

3. Un vez creado, vamos a grupo de recursos, seleccionamos el nombre de recurso que utilizamos y dentro podemos ver la cuenta de Azure Search que creamos. Le hacemos clic y veremos la información necesaria de nuestra cuenta.

Volvamos a nuestro panel de Azure Search. Para conectar nuestra base de datos debemos seleccionar desde la barra de opciones “Importar Datos” y seleccionamos Muestras para nuestro demo:

Luego de vincularlo veremos la pantalla de configuración de nuestros índices que descubrirá, desde nuestro origen de datos. Vamos a dejarlos por default.

Por último, seleccionamos un nombre para nuestro índice.  El tiempo el cual queremos que se refresque nuestros índices es configurable. Cuales son retornables, cuales filtrables, por cual vamos a ordenar, etc. Para esto último debemos habilitarlo en el datasource como dice en el mensaje. Por el momento no será necesario.

Ahora, una vez que el indexador termine podremos ingresar al explorador de búsqueda para probar algunas consultar.

En la imagen podemos ver que tenemos un cuadro donde podemos ingresar nuestra consulta, como también, un cuadro donde podemos obtener la url de esa búsqueda. Por último, un cuadro con el resultado de la búsqueda.

Vamos a escribir la siguiente consulta y veremos los resultado que se corresponden a nuestros parámetros:

search=granite&amp;country=us

Conclusión

Azure Search es una excelente herramienta para realizar potentes búsquedas desde nuestros orígenes de datos existentes. No es necesario crear una plataforma para esto. Azure Search pone a nuestra disponibilidad la misma experiencia de usuario y la misma potencia de un motor búsqueda especializado para nuestra aplicaciones.

En este post hemos hablamos sobre Azure Search, sus características, como configurar nuestra cuenta y configurar nuestros primeros índices para hacer pruebas. En el próximos post integraremos estos índices a una aplicación en .Net para poder explorar un poco más las capacidades en un sitio web.