Archivo de la etiqueta: Windows Azure

Laboratorios del curso Windows Azure Technical Training Santiago #windowsazure

Durante el curso Windows Azure Technical Training Santiago Chile, entrenamiento fuertemente orientado a la práctica, se realizaron 10 ejercicios para los desarrolladores y 12 ejercicios para los IT pro.
Los recursos utilizados para estos ejercicios son de libre acceso, por lo cual cualquier persona puede realizarlos si tiene una cuenta de Windows Azure. Si no la tiene, puede abrir una trial por 30 días de manera gratuita.

Para los desarrolladores de software, la batería de ejercicios es la siguiente:

1. Azure Web Sites
https://rgodinhodemo.blob.core.windows.net/hol/ASPNETAzureWebSites.zip

2. SQL Server on Azure Virtual Machines
https://rgodinhodemo.blob.core.windows.net/hol/ConnectingApplicationsVNet.zip

3. Windows Azure Mobile Services
http://www.windowsazure.com/en-us/documentation/articles/mobile-services-html-get-started/Windows

4. Windows Azure Media Services
https://jpgarcia.cl/2013/04/02/windows-azure-media-services-publicar-videos-para-ios-y-windows-phone-azure/

5. Windows Azure Active Directory
http://www.asp.net/identity/overview/getting-started/developing-aspnet-apps-with-windows-azure-active-directory
http://blogs.technet.com/b/ad/archive/2013/06/26/improved-windows-azure-active-directory-integration-with-asp-net-amp-visual-studio.aspx

6. Windows Azure SQL Database
https://rgodinhodemo.blob.core.windows.net/hol/IntroSQLDatabase.zip

7. Windows Azure Diagnostic & Patterns
http://www.windowsazure.com/en-us/manage/services/web-sites/choose-web-app-service/Troubleshooting
http://msdn.microsoft.com/en-us/library/windowsazure/hh771389

8. Windows Azure Service Bus
http://www.windowsazure.com/en-us/develop/net/how-to-guides/service-bus-queues/
http://www.windowsazure.com/en-us/develop/net/how-to-guides/service-bus-relay/

9. Windows Azure Cloud Services
http://msdn.microsoft.com/en-us/library/ff687127.aspx

10. Windows Azure Storage
http://www.windowsazure.com/en-us/develop/net/tutorials/multi-tier-web-site/1-overview/

Para los profesionales de infraestructura , la batería de ejercicios es la siguiente:

1. Windows Azure Virtual Machines
https://rgodinhodemo.blob.core.windows.net/hol/IntroToWindowsAzureVirtualMachines.zip

2. SQL Server on Azure Virtual Machines
http://www.windowsazure.com/en-us/documentation/articles/virtual-machines-provision-sql-server/

3. Azure SQL Database
http://www.windowsazure.com/en-us/documentation/articles/sql-database-create-configure/
http://www.windowsazure.com/en-us/documentation/articles/sql-database-deploy/
http://www.windowsazure.com/en-us/documentation/articles/sql-database-manage-windows-azure-SSMS/

4. Windows Azure Virtual Network
http://msdn.microsoft.com/en-us/library/windowsazure/dn133792.aspx
https://jpgarcia.cl/2013/06/07/como-usar-custom-load-balance-y-affinity-en-windows-azure-windowsazure/

5. Sharepoint on Azure Virtual Machines
http://msdn.microsoft.com/en-us/library/windowsazure/dn275959.aspx
http://blogs.technet.com/b/keithmayer/archive/2013/01/07/step-by-step-build-a-free-sharepoint-2013-lab-in-the-cloud-with-windows-azure-31-days-of-servers-in-the-cloud-part-7-of-31.aspx

6. Windows Azure Stoarge
http://michaelwasham.com/windows-azure-powershell-reference-guide/copying-vhds-blobs-between-storage-accounts/
http://msdn.microsoft.com/en-us/library/jj720558%28v=sql.120%29.aspx
https://blogs.technet.com/b/heyscriptingguy/archive/2014/01/24/create-backups-of-virtual-machines-in-windows-azure-by-using-powershell.aspx

7. Windows Azure Managment Services
http://www.windowsazure.com/en-us/manage/services/cloud-services/how-to-scale-a-cloud-service/
http://msdn.microsoft.com/en-us/library/windowsazure/dn306638.aspx
http://www.windowsazure.com/en-us/manage/services/storage/how-to-monitor-a-storage-account/

Business Rule Engine en Windows Azure #windowsazure

Introducción

Trabajando con un partner mexicano de Guadalajara me encontré con el siguiente requerimiento:

Necesito crear flujos de trabajo que evalúen reglas de negocio que estén fuera del código. Además necesito que estos flujos de trabajo se expongan como servicios para que diferentes sistemas los llamen.

Para los que desarrollan en .NET desde la version 3.5 del framework tienen disponible Workflow Fundation(WF). En este artículo, vamos a desarrollar una solución muy simple para ambos requerimientos utilizando WF4.  La idea es utilizar las capacidades que tiene WF para trabajar con reglas, una de las partes más interesantes de WF. El escenario a desarrollar se muestra en el diagrama 1.

00

La solución final se basa en construir un proyecto Workflow Services, que es la publicación de manera nativa de los WF como servicios usando WCF, los que se publicarán en un Web Role de Windows Azure. Estos workflows pueden evaluar un conjunto de regalas de negocio que están definidas en un archivo XML externos al código. La idea es almacenar el set de regalas de negocio en Windows Azure Blob Storage, de manera que estén disponibles para los Workflow Services. Complementario a lo anterior, vamos a construir un editor y probador de reglas de negocio en una aplicación Windows de consola. Está aplicación nos permite cambiar las reglas en tiempo de ejecución sin necesidad de volver a hacer deploy porque están absolutamente desacopladas del código.

Este articulo está dividido en dos partes, primero vamos a construir una biblioteca que nos facilite el trabajo con reglas y una aplicación de consola para probarla. En la segunda parte vamos a usar la biblioteca desde los Workflows para evaluar reglas en tiempo de ejecución.

Primera parte: Biblioteca y pruebas

Biblioteca de ayuda para usar Reglas de Negocio

Comenzamos por crear una biblioteca de ayuda para utilizar las reglas de negocio de WF desde la aplicación de consola para administración   y  evaluación desde los Wrokflow services en tiempo de ejecución.  Esta biblioteca nos simplifica todo el manejo de las reglas de negocio y está compuesta por la clase BREClient  la que se muestra en el siguiente diagrama.

01

Clase BREClient: Edición de reglas

Lo primero que necesitamos hacer es poder cargar o crear RuleSet. Para ello necesitamos utilizar desde nuestra biblioteca el Blob Storage de Windows Azure. Para ello debemos agregar las librerías clientes de Windows Azure Storage, como se muestra en la siguiente imagen.

3

Como segundo paso agregamos los Assemblies de Windows Worflow Fundation, como se muestra en la siguiente imagen.

4

El método LoadRuleSet de la clase BREClient nos permite cargar o crear un RuleSet desde un archivo XML que se almacena en un contenedor específico del Blob Storage.

///
/// Load or create RulseSet from XMl file RuleSetXmlFile stoarge in RuleSetContainer
        ///
        ///Container´s name
        ///Xml File´s name
        ///
        private RuleSet LoadRuleSet(string RuleSetContainer,string RuleSetXmlFile)
        {
            RuleSet ruleset;
            XmlTextReader reader;
            try
            {
                CloudBlobContainer container = blobClient.GetContainerReference(RuleSetContainer);
                CloudBlockBlob blockBlob = container.GetBlockBlobReference(RuleSetXmlFile);

                if (BlobExist(blockBlob))
                {
                    //Load RuleSet From XML
                    using (var memoryStream = new MemoryStream())
                    {
                        blockBlob.DownloadToStream(memoryStream);
                        memoryStream.Position = 0;
                        reader = new XmlTextReader(memoryStream);
                        WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
                        object results = serializer.Deserialize(reader);
                        ruleset = (RuleSet)results;
                    }
                }
                else
                {
                    //Create New RuleSet
                    ruleset = new RuleSet();
                }
            }
            catch (Exception X)
            {
                //TODO: manage exception
                throw X;
            }
            return ruleset;
        }

El segundo método que necesitamos en la clase BREClient es  SaveRuleSet, que nos permite persistir el RuleSet en un archivo XML en el Blob Storage.

private void SaveRuleSet(string RuleSetContainer,string RuleSetXmlFile, RuleSet ruleset)
        {
            MemoryStream memoryStream = new MemoryStream();
            XmlTextWriter writer = new XmlTextWriter(memoryStream, null);
            WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
            serializer.Serialize(writer, ruleset);
            try
            {
                CloudBlobContainer container = blobClient.GetContainerReference(RuleSetContainer);
                CloudBlockBlob blockBlob = container.GetBlockBlobReference(RuleSetXmlFile);
                memoryStream.Position = 0;
                blockBlob.UploadFromStream(memoryStream);
            }
            catch (Exception)
            {
                //TODO: manage exception
                throw;
            }
            memoryStream = null;
        }

Con estos dos métodos podemos editar las reglas de negocio utilizando la interfaz Rule Set Editor, como se muestra en la siguiente imagen.

02

Este editor es parte del Windows Workflow Fundation, por lo que solo tenemos que invocarla para editar las reglas y luego al presionar OK podemos guardarlas para ser usadas desde diferentes Workflows. El método EditRuleDialog carga las reglas desde el archivo XML, lo edita y luego actualiza con los cambios realizados.

///
/// Load or create Ruleset, Edit with Rule Set Editor and save the changes in XML file.
///
///Type Class used in Rules
///Xml File Blob Container
///XML File´s name
public void EditRuleDialog(Type TargetType, string RuleSetContainer, string RuleSetXmlFile)
{
   RuleSet ruleset = null;
   //load or creat if not exits
   ruleset = this.LoadRuleSet(RuleSetContainer, RuleSetXmlFile);
            RuleSetDialog dialog = new RuleSetDialog(TargetType, null, ruleset);
   DialogResult result = dialog.ShowDialog();
   if (result == DialogResult.OK)
     {
        SaveRuleSet(RuleSetContainer, RuleSetXmlFile, dialog.RuleSet);
      }
}

Con esta implementación se puede editar reglas de negocio absolutamente desacopladas del código de los Workflows. El siguiente código permite editar reglas utilizando la clase BREClient.

static void EDitar()
{
  //conn is Azure Storage´s connection string
   BREClient RuleClient = new BREClient(conn);
  //Target Class to use in Rules
  Person mySubjectEval = new Person();
  string RuleContainer = "demo";
  string RuleXmlFile = "PersonCredit.xml";
  RuleClient.EditRuleDialog(typeof(Person), RuleContainer, RuleXmlFile);
}

Clase BREClient: Evaluación de reglas

Una vez creadas las reglas de negocio y almacenadas en el storage de azure podemos utilizarlas desde diferentes clientes, sin importar si son Workflows o aplicaciones .NET de otra naturaleza, ya que la clase BREClient nos dará acceso al Framework de reglas.

La evaluación de las reglas se hace utilizando  la clase BREClient con el método público RuleExecute donde se carga el Rulset y se evalúan las reglas. El método privado hace la evaluación realmente, mientras que el público le provee el contexto para la ejecución.

///
/// Execute Rule evaluation
///
///Object used in rules
///RuleSet
private void RuleExecute( Object Target, RuleSet ruleset)
{
 try
    {
      RuleValidation validation = new RuleValidation(Target.GetType(), null);
      RuleExecution engine = new RuleExecution(validation, Target);
      ruleset.Execute(engine);
     }
catch (Exception X)
      {
        System.Diagnostics.Trace.WriteLine(X.Message, "Error");
        throw X;
       }
}
///
/// Execute rule evaluation with or without rulset´s cache
///
///Rulset´s blob container
///Rulset´s Xml file
///Object used in rules
///Use Rulset Cache
public void RuleExecute(string RuleSetContainer, string RuleSetXmlFile, Object Target, bool UseRuleCache)
{
   RuleSet ruleset = null;
   if (UseRuleCache)
   {
     string key = string.Format("{0}/{1}", RuleSetContainer, RuleSetXmlFile);
     if (!RuleSetCache.ContainsKey(key))
     {
        ruleset = LoadRuleSet(RuleSetContainer, RuleSetXmlFile);
        RuleSetCache.Add(key, ruleset);
      }
      ruleset = (RuleSet)RuleSetCache[key];
      this.RuleExecute(Target, ruleset);
    }
    else
    {
      ruleset = LoadRuleSet(RuleSetContainer, RuleSetXmlFile);
      this.RuleExecute(Target, ruleset);
   }
}

Para probar la evaluación de las reglamos podemos usar el siguiente método donde se crea el objeto subjectX que es de la clase Person que se utiliza en la regla.

static void Test()
{
  Person subjectX= new Person();
  BREClient RuleClient = new BREClient(conn);
  DateTime timezero = DateTime.Now;
  for (int i = 0; i < 10; i++)
  {
    subjectX.Age = i;
    RuleClient.RuleExecute(RuleContainer, RuleXmlFile, subjectX,false);
    Console.WriteLine(string.Format("Age= {0} rule response {1}", i, subjectX.RuleEval));
   }
   DateTime timeOne = DateTime.Now;
   Console.WriteLine("Total time: " + (timeOne - timezero).TotalSeconds.ToString());
   Console.WriteLine("");
}

La regla que estamos usando es la siguiente: si la propiedad Age es menor que 5, la propiedad RuleEval de la clase Person es verdadero sino falso. Esto se muestra en la siguiente imagen.

02

Al ejecutar la prueba obtenemos la siguiente respuesta, que obedece a la regla definida.

03

El tiempo de ejecución es alrededor de 0.95 segundos por llamada. Esto ocurre porque en cada evaluación accede al archivo XML que está en el Blob Storage. En el caso en que las reglas no cambian en tiempo real podemos optimizar los tiempos utilizando un cache local para los RulSet. El siguiente método optimiza las llamada a las mismas reglas pero usando cache.

static void TestCache()
{
  Person subjectX = new Person();
  BREClient RuleClient = new BREClient(conn);
  DateTime timezero = DateTime.Now;
  for (int i = 0; i < 10; i++)
    {
      subjectX.Age = i;
      RuleClient.RuleExecute(RuleContainer, RuleXmlFile, subjectX,true);
      Console.WriteLine(string.Format("Age= {0} rule response {1}", i, subjectX.RuleEval));
     }
     DateTime timeOne = DateTime.Now;
     Console.WriteLine("Total time: " + (timeOne - timezero).TotalSeconds.ToString());
     Console.WriteLine("");
}

Las respuestas a esta segunda llamada toman sólo 0,1,83 segundos por regla porque sólo hace una lectura al blob storage y alamacena en un Hashtable el objeto RuleSet por lo que todas las otras evaluaciones la realiza con el objeto ya guardado en memoria.

04

Segunda parte: Workflows como Servicios

En esta segunda parte vamos a desarrollar el proyecto de Workflow Services, donde implementaremos los Workflows que utilizaran la clase BREClient para evaluar las reglas de negocio alacenadas en el archivo XML en Azure Blob Storage.

Workflow EvalPerson

El primer workflow a desarrollar es la evaluación de un sujeto basado en la clase Person. El servicio recibe como parámetro una instancia de Person y lo regresa al cliente después de hacer la evaluación como se muestra en la siguiente imagen.

05

El mensaje de entrada se llama data y el del tipo HelperBRE.SampleSubject.Person para poder aplicarle las mismas reglas que utilizamos en la primera parte del artículo, con la aplicación de consola que crea, edita y graba reglas de negocio. El WSDL que expone el servicio se muestra en la siguiente imagen.

06

Ahora, si miramos el contenido de la actividad Flow: Rule Evaluation podemos ver que está compuesta por una actividad del tipo InvokeMethod llamada “Rule Eval”, Decision y Assign llamada “SalaryPlus”. Estas actividades y sus conectores se muestran en la siguiente imagen. Además de las actividades, se deben declarar las variables que se utilizaran en el workflow, las que aparecen en la tabla de variables.

07

La actividad “Rule Eval” requiere que se declare el método que se llamará y también que parámetros se utilizarán. Aquí es donde utilizamos el objeto BREClientWF4 de la clase BRClient para invocar la evaluación de las reglas de la misma forma que utilizamos en la primera parte del artículo. Como parámetros de la llamada usamos las variables ya definidas RuleContainer, RuleXmlFile, data y el valor true. La configuración de “Rule Eval” se muestra en la siguiente imagen.

08

Una vez realizada la evaluación de las reglas podemos tomar una decisión basados en la propiedad data.RuleEval, valor que fue fijado en la evaluación de la regla de negocio. Si el valor es verdadero, vamos a modificar el valor de la propiedad data.Salary aumentándolo en 10%.

Por último, después de ejecutar el Flowchart respondemos al cliente que nos ha llamado, regresándole el mismo objeto data pero con los valores modificados en base a la evaluación de las reglas y la asignación de valor en el workflow.

Para probar este workflow ejecutamos el proyecto, que es un Web Role, y podemos utilizar el programa de pruebas WCF Test Cient. Como primera prueba llamamos al Workflows con los valores 0, False y 100 y nos responde 0, True y 100. Esto es porque la evaluacion de la regla de negocio dio True entonces el workflow le aumentó 10% el salario al sujeto evaluado como se muestra en la siguiente imagen.

09

Como segunda prueba ejecutamos el workflow con los valores 10, False y 100 y nos regresa 10, False y  100. Esto es porque la regla de negocio respondió False y no tuvo entonces aumento en el workflow como se muestra en la siguiente imagen.

010

Con estas dos pruebas comprobamos que nuestro Workflow con invocación a las reglas de negocio funciona perfectamente por lo que podemos crear un cliente que nos permite utilizarlo. El siguiente código, muestra como iniciar el Workflow utilizando código.  La idea de este método de prueba es que hace 10 evaluaciones y nos muestra su resultado por pantalla, cada evaluación es una llamada al servicio que expone el Workflow.

static void TestWF4WFC()
{
  Person subjectX = new Person();
  srvEvalPersona.ServiceClient proxy = new srvEvalPersona.ServiceClient();
  DateTime timezero = DateTime.Now;
  for (int i = 0; i < 10; i++)
    {
     subjectX.Age = i;
     subjectX.Salary = 100;
     proxy.EvalPersona(ref subjectX);
     Console.WriteLine(string.Format("Age= {0} rule response {1} and Salary={2}", i,subjectX.RuleEval,subjectX.Salary));
     }
     DateTime timeOne = DateTime.Now;
     Console.WriteLine("Total time: " + (timeOne - timezero).TotalSeconds.ToString());
     Console.WriteLine("");
}

La respuesta a cada llamada se muestra en la siguiente imagen, los resultados son coherente con la regla definida. Ahora, el tiempo de ejecución de las 10 evaluaciones toma 10.49 segundo porque estamos haciendo 10 llamadas al servicio y cada llamada a su vez carga el RulSet desde el storage.

011

Podemos optimizar esto, construyendo un Workflow que haga la evaluación de varias personas en una sola llamada y usar RuleSet Cache para que sea lo más rápido posible la evaluación. Este nuevo workflow tiene la siguiente estructura: recepción de la petición, ciclo ForEach donde se evalúa cada persona y respuesta al cliente como se muestra en la siguiente imagen.

A diferencia del primer workflow, este recibe como mensaje un objeto del tipo Persons[], es decir un arreglo de personas a evaluar.

012

El archivo WSDL que describe a este nuevo Workflow se muestra en la siguiente imagen.

013

A diferencia del primer workfow, aquí tenemos que evaluar a todas las personas que vienen en la llamada por lo que utilizamos la actividad ForEach, donde cada persona a evaluar es asignada al objeto subject. Luego en cada iteración se hace el llamado a RuleExecute usando el objeto BREClientWF4 del tipo BREClient y aplicando o no el cambio de salario dependiendo de resultado de la evaluación de la regla de negocio, como se muestra en la siguiente imagen.

014

Para poder probar este nuevo workflow, utilizamos el código que se muestra a continuación. En este procedimiento creamos un arreglo de 10 personas y les asígnanos el mismo salario pero diferente edad a casa uno.

static void TestWF4WFC_Bacth()
{
  Person[] subjectXs = new Person[10];
  for (int i = 0; i < 10; i++)
  {
     subjectXs[i] = new Person();
     subjectXs[i].Age = i;
     subjectXs[i].Salary = 100;
  }
  srvEvalPersonaBatch.ServiceClient proxy = new srvEvalPersonaBatch.ServiceClient();
  DateTime timezero = DateTime.Now;
  //execute
  proxy.EvalPersonaBatch(ref subjectXs);
  foreach (var subject in subjectXs)
  {
    Console.WriteLine(string.Format("Age= {0} rule response {1} and Salary={2}", subject.Age, subject.RuleEval, subject.Salary));
  }
  DateTime timeOne = DateTime.Now;
  Console.WriteLine("Total time: " + (timeOne - timezero).TotalSeconds.ToString());
  Console.WriteLine("");
}

Luego hacemos solo una llamada al servicio y obtenemos la respuesta. Con la respuesta recorremos el arreglo e imprimimos el resultado de la evaluación de cada cliente. En la siguiente imagen podemos ver el resultado de ejecutar la prueba obteniendo resultados coherentes con las regla de negocio y en un tiempo de 0.069 segundos por regla.

015

Conclusiones

En este artículo hemos visto cómo podemos utilizar el motor de reglas de Windows Workflow Fundation desde una aplicación de consola. Esto lo hemos hecho utilizando una clase de apoyo llamada BREClient. Un punto importante a tener en cuenta es el uso de cache local para el RuleSet ya que leer en cada evaluación las reglas desde el archivo XML almacenado en Blob Storage hace muy lento las evaluaciones.

En la segunda parte del artículo, utilizando BREClient desde dos workflow diferentes. El primero es una llamada para evaluar a una persona y el segundo para evaluar a grupos de personas, viendo claramente la optimización de la evaluación al hacer solo una llamada por grupo.

Esta es una solución muy simple para el problema propuesto por el partner, pero muy efectiva. Ademas es una solución estándar por lo cual los costos de desarrollo y mantención son más bajos que en un BRE custom.

El código fuente de este artículo está en GIT, en el siguiente link.

016

Presentación: Using windows azure to develop secure and deploy cloud applications Santiago Chile

vs2013_a

En el contexto del lanzamiento de Visual Studio 2013 presenté las siguientes laminas. En la exposición se muestran los conceptos básicos de Windows Azure y las herramientas que VS2013 trae para facilitar el desarrollo de aplicaciones en la Nube.

En las siguientes ligas se pueden hacer tutoriales parecidos a las demostraciones  que vimos en la presentación.

  1. Escenario de DEV/TES de Sharepoint en Azure VM
  2. Creación de Web Sites en Azure
  3. Debugging remoto con Visual Studio 2013
  4. Crear una aplicación Windows Phone 8 con BackEnd en Azure Mobile Services
  5. Publicar servicios internos en Azure Service Bus Relay

Windows Azure Virtual Machine: múltiples sitios en una VM #windowsazure

Dos clientes diferentes, uno en Santiago y otro en Bogotá me han preguntado cómo pueden hospedar distintos sitios web en una máquina virtual de Windows Azure, cada una con su propio dominio. En este artículo se muestra como hospedar 3 sitios web en misma máquina virtual cada uno con su propio DNS. Los sitios de prueba son los siguientes:

  1. xxx.jpgarcia.cl
  2. yyy.jpgarcia.cl
  3. zzz.agrotrade.cl

Los tres sitios anteriores se encuentran en la misma máquina virtual, la que pertenece al  Cloud Services multisitio.cloudapp.net. La idea es que cuando un usuario cargue en su navegador una de esas URL, el DNS server lo envía a al cloud service. Este mediante la configuración de EndPoint de la máquina virtual (VM), envía el requerimiento al puerto 80 de la VM. En este momento es cuando el ARR intercepta la llamada y utilizando las reglas de ruteo envía el requerimiento al sitio web que corresponda, el cual está hospedado en la misma máquina virtual pero en diferente puerto. Todo esto es trasparente para el usuario final, quien no sabe que todo esto está ocurriendo tras bambalinas. La figura 1, muestra el ejemplo de lo que ocurre cuando se llama al sitio http://xxx.jpgarcia.cl. El requerimiento es ruteado por ARR al sitio xxx hospedado en el puerto 8080.

0

Ahora vamos a revisar cómo configurar el escenario de ejemplo paso a paso, lo que dará como resultado que hospedaremos 3 sitios en la misma VM, cada uno con su propio DNS.

Paso 1: Dar de alta una máquina virtual con IIS 7

Primero creamos una máquina virtual en Windows Azure desde la galería con la imagen de Windows Server 2012 Datacenter. Los datos para la creación son los siguientes:

  • Virtual machine name: vmMultiSitio
  • Size: Large
  • New user name: jpg
  • Password: xxxxxx
  • DNS name: multisitio

Se termina el asistente y comienza el aprovisionamiento de la VM.

1

Una vez aprovisionada la VM nos conectamos utilizando terminal server. La instalación  de Internet Information Server (IIS) se hace agregando el rol Web Server (IIS) desde la consola de Server Manager, siguiendo el asistente con todas las opciones por defecto.

2

Una vez terminada la agregación del Rol obtenemos esta confirmación.

Paso 2: Crear los 3 sitios Web en la VM

Ahora,  nos movemos a la consola Internet Information Server (IIS) Manager para crear los 3 sitios Web que se hospedaran en este servidor. Por defecto tenemos un sitio Web llamado Default Web Site que está configurado en el puerto 80. Ahora creamos el sitio Web llamado XXX, como se muestra en la siguiente imagen.

4

Ahora, en el sitio xxx, creamos la página HMTL llamada iisstart.html con el siguiente código.

<!DOCTYPE HTML>
<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
		<title>Microsoft Internet Information Services 8</title>
	</head>
	<body>
		Hola Soy el Servido XXX del puerto 8080
	</body>
</html>

Para el segundo sitio ocupamos la siguiente configuración cuando creamos el sitio Web.

5

Volvemos a crear una página HTML llamada iisstart.html con el siguiente código pero en el directorio del sitio yyy.

<!DOCTYPE HTML>
<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
		<title>Microsoft Internet Information Services 8</title>

	</head>
	<body>
		Hola Soy el Servido YYY del puerto 8081
	</body>
</html>

Por último, creamos el tercer sitio llamado zzz para el sitio xxx.agrotrade.cl con la siguiente configuración.

6

Volvemos a crear una página HTML llamada iisstart.html con el siguiente código pero en el directorio del sitio zzz.

<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
		<title>Microsoft Internet Information Services 8</title>
	</head>
	<body>
		Hola Soy el Servido ZZZ del puerto 8082
	</body>
</html>

Al terminar estos 3 sitios, tenemos la siguiente vista de sitios en nuestro servidor.

7

Paso 4: Instalar Application Request Routing (ARR)

Ya tenemos nuestra máquina virtual con II8 Instalado y los sitios Web creados. Ahora, vamos a instalar ARR utilizando la herramienta Get New Web Platform Components, desde el menú de acciones al nivel de servidor, como se muestra en la siguiente imagen.

8

Esta acción nos lleva a un sitio web donde tenemos el botón de instalación. No podemos descargar nada hasta cambiar la configuración IE Enhanced Security Configuration, lo configuramos como Off para administradores.

9

Volvemos a IE, lo reiniciamos, bajamos el software  y lo ejecutamos inmediatamente. Cuando esté listo, nos presenta la pantalla de Web Platform Installer 4.5. Aquí buscamos ARR, seleccionamos Application Request Routing 2.5 y luego hacemos click en instalar.

10

Finalizado el proceso de instalación, obtenemos la siguiente confirmación.

11

Cerramos IIS Manager.

Antes de configurar el DNS, agregamos un EndPoint en la VM llamado www, no balanceado como muestra la siguiente figura. La idea es que todos los requerimientos lleguen al puerto 80 de balanceador de carga del Cloud Services y de ahí se lo envíe al puerto 80 de nuestra máquina virtual.

11a

Paso 5: Configurar DNS de los 3 sitios Web

Ya tenemos VM con IIS 8,  los 3 sitios Web creados y ARR instalado. Ahora necesitamos ir a nuestro servidor de DNS y configurar que las URL xxx.jpgarcia.cl, yyy.jpgarcia.cl y zzz.agrotrade.cl para que utilizando el registro CNAME sean direccionados al Cloud Services multisitio.cloudapp.net.

En este punto depende de que herramienta de DNS que se utilice, yo uso WordPress.com. En la siguiente imagen podemos ver los registros CNAME destacados en amarillo.

12

Ahora, para la URL zzz.agrotrade.cl tenemos el siguiente registro.

13

Ahora hacemos las pruebas de configuración de DNS.

1. Cargamos http://multisitio.cloudapp.net/  y vemos la página por defecto de IIS 8, que se sirve desde el Web Server llamado Default.

14

2. Cargamos http://xxx.jpgarcia.cl/ y vemos la página por defecto de IIS 8, que se sirve desde el Web Server llamado Default.

15

3. Cargamos http://yyy.jpgarcia.cl/ y vemos la página por defecto de IIS 8, que se sirve desde el Web Server llamado Default.

16

4. si cargamos http://zzz.agrotrade.cl/ y vemos la página por defecto de IIS 8, que se sirve desde el Web Server llamado Default al igual que los 3 casos anteriores.

Paso 6: Configurar las reglas de ruteo

Llegamos ahora a la parte más importante del artículo, es aquí donde vamos a configurar las reglas de ruteo basados en el la variable HTTP_HOST. Volvemos a IIS Manager y en el nivel de servidor seleccionamos el icono URL Rewrite. Entonces, en acciones seleccionamos Add Rule(s), y en el primer dialogo utilizamos Blank rule con los siguientes valores para el sitio xxx.

17

18

19

Para crear la regla aplicamos el cambio en el panel de acciones.

Con esta regla de ruteo le decimos a IIS que al momento de recibir una petición para el sitio xxx.jpgarcia.cl sobre escriba la dirección de la petición hacia el sitio localhost en el puerto 80, donde está el sitio XXX en nuestra máquina virtual. Como utilicé la opción Rewrite y no Redirect, necesitamos configurar el proxy de ARR para que así el cliente no sea enviado al otro sitio, sino que el proxy llame al sitio XXX le envié la respuesta el cliente sin que el browser haga nada para esto. Esta es la forma de lograr la trasparencia para el usuario final del sitio XXX.

El proxi se active en el icono Application Request Routing Cache, acción Server Proxy Settings como se muestra en la siguiente imagen.

20

Para activar el proxy, después de seleccionar el Checkbox hacemos click en aplicar del panel de acciones.

Para completar la confiugracion creamos dos reglas más, una para el sitio YYY y otra para ZZZ. Para hacerlo seguimos el mismo procedimiento que usamos para el sitio XXX, con lo cual quedamos con las siguientes tres reglas.

21

Paso 7: Probar

Luego de toda la configuración podemos probar si las reglas están funcionando correctamente. Para eso, simplemente cargamos las 3 URL y obtenemos como resultado que cada requerimiento es respondido de manera trasparente por cada correspondiente sitio de nuestra máquina virtual. Además, podemos probar el sitio Default que sigue funcionando, lo que quiere decir que tenemos 4 Web Sites en la misma máquina virtual, funcionando con sus propios nombres de DNS.

22

Comentarios al cierre

Este es un ejemplo para ilustrar el uso de ARR en este escenario, en producción se puede usar pero hay que utilizarlo en esquema de alta disponibilidad. ARR tiene por diseño la capacidad de trabajar en HA.  Lo mismo pasa con los sitios Web, no es buena práctica tener una sola instancia de un sitio, siempre dos o más!

Links Relacionados