Mostrando entradas con la etiqueta Microsoft Azure. Mostrar todas las entradas
Mostrando entradas con la etiqueta Microsoft Azure. Mostrar todas las entradas

sábado, 14 de marzo de 2015

Microsoft Azure Cloud Service - VIP swap feature

El Cloud Service de Microsoft Azure provee la posibilidad de implementar nuestro servicio en dos entornos propios: Production y Staging, y mediante un proceso denominado VIP swap intercambiar los mismos.

Esto es grandioso porque permite implementar un servicio en el entorno de Staging, probarlo, y cuando está todo ok hacer el swap que lo dejará en Production, pero hay que tener en cuenta que este 'intercambio de implementaciones', o 'promoción del servicio en ensayo al entorno de producción', tal como se nombra en varios documentos, en verdad es solamente un intercambio de punteros (la VIP y URL de cada uno de los entornos), las implementaciones en sí no se ven modificadas por este proceso en su configuración ni estado.

Algunos puntos a tener en cuenta:
  • Cada uno de los entornos de un Cloud Service poseen tres atributos propios:
    • Su denominación: Staging o Production
    • Una virtual IP pública, o VIP.
    • ..y una URL: <nombredns>.cloudapp.net (Production), o <guid>.cloudapp.net (Staging)
  • Tanto la VIP como la URL de Staging se mantienen durante todo el ciclo de vida de la implementación mientras no sea borrada (no cambia entre deploys). 
  • Cuando una implementación es borrada de un entorno recién entonces se liberan estos valores, y al hacer una nueva implementación sobre ese entorno siempre se asigna un nuevo valor de VIP. La URL de Staging <guid>.cloudapp.net solo cambia si este proceso de borrado y nueva implementación se lleva a cabo sobre el entorno de Staging.
  • Antes de ejecutar el VIP swap debemos asegurarnos de que la configuración de la implementación en Staging sea la adecuada para pasarla a Production, ya que el proceso no altera ninguno de los valores en cuanto a cantidad de instancias de los roles, ni configuración de autoscaling.
  • Las conexiones establecidas con cada implementación al momento de ejecutar el VIP swap se mantendrán así hasta su cierre por parte del cliente o servidor, no serán canceladas por el proceso de intercambio. Solo las nuevas conexiones son dirigidas a la nueva implementación que ocupa cada entorno.
  • La opción de VIP swap aún no está disponible en el Preview Portal; para ejecutarlo tendremos que servirnos del Management Portal, o invocando la Microsoft Azure Management Service Rest API directamente, o a través del wrapper que conforman las Microsoft Azure Management Libraries, o MAML.
Sección de Management Portal - Cloud Service Dashboard
Sección del Management Portal - Cloud Service Dashboard

Bueno, sigo leyendo el Exam Ref 70-532 Developing Microsoft Azure Solutions a ver como continúa la historia de los Cloud Services.

sábado, 31 de enero de 2015

Tienda online en ASP.NET 5 sobre Docker

Intro

Entusiasmado con la posibilidad que brinda ASP.NET 5 de correr mis sitios web sobre distintas plataformas, me puse a averiguar y escribir un resumen de como levantar un sitio y correrlo sobre Docker dentro de una VM Ubuntu de Microsoft Azure... la sorpresa fue que no te lleva mas de 10 minutos, y funciona de maravillas.


Requisitos

  • Suscripción de Microsoft Azure.
  • Una VM Ubuntu Trusty 14.04 como mínimo, con el puerto 80 habilitado.
  • Estar registrado en Docker.com si queremos salvar allí la nueva imagen creada.

Contenido

  1. Preparar el contenido de la nueva imagen.
  2. Construir la imagen Docker con nuestra aplicación.
  3. Levantar un nuevo container con nuestra imagen.
  4. Salvar nuestra imagen en Docker Hub.

Docker 1. Preparar los componentes de la nueva imagen

La imagen Docker que vamos a crear para correr nuestra aplicación MVC MusicStore estará basada en la microsoft/aspnet publicado por Microsoft meses atrás que, si bien aún está en preview, sirve perfectamente para nuestro propósito.

Actualizamos nuestro Ubuntu; instalamos Docker según se explica en docs.docker.com/installation/ubuntulinux; y también nos aseguramos de contar con Git:
sudo apt-get update
sudo apt-get install docker.io
sudo apt-get install git-core

Por último clonamos en la carpeta local storeapp el proyecto MVC MusicStore de GitHub, con el comando:
git clone http://github.com/aspnet/MusicStore storeapp

Git clone
Git clone

2. Construir la imagen Docker de nuestra aplicación

Nos movemos a la carpeta storeapp/src/MusicStore y ahí creamos el archivo Dockerfile que usaremos para configurar nuestra imagen. Podes crear el archivo con nano o el editor que prefieras:
cd storeapp/src/MusicStore
nano Dockerfile

Copia el siguiente contenido dentro del archivo Dockerfile (las lineas que comienzan con # son comentarios):
# Base image
FROM microsoft/aspnet

# Copy project folder into image and restore Nuget packages
COPY . /app
WORKDIR /app
RUN ["kpm", "restore"]

# Run de web site
EXPOSE 5004
ENTRYPOINT ["k", "kestrel"]

..y creamos la imagen usando el comando:
sudo docker build -t storeapp .

Esto demora un poco, paciencia.

3. Levantar un nuevo container con nuestra imagen

Podemos ver las imágenes en nuestro sistema mediante el comando Docker images, luego levantamos nuestra imagen en un nuevo container con run, y por ultimo listamos los containers con el comando ps:
sudo docker images
sudo docker run -t -d -p 80:5004 --restart=on-failure:10 storeapp
sudo docker ps -a

Creando el Docker container con nuestra imagen

Y ya tenemos nuestra imagen corriendo en un container de Docker en nuestra VM, publicado en el puerto 80 de Ubuntu (no olvides configurar el endpoint en Azure).

4. Salvar nuestra imagen en Docker Hub

Ahora si queremos salvar la imagen en Docker Hub para utilizarla desde cualquier otra VM, o publicarla para la comunidad, podemos agregarle un tag y hacerle un push (previamente tenemos que registrarnos en Docker.com).

Tanto el image id (934e56caf9b8), como el nombre de la cuenta registrada (seketman), deben cambiarse por los valores que corresponden:
sudo docker tag 934e56caf9b8 seketman/storeapp:demo
sudo docker push seketman/storeapp:demo

Nuestro sitio funcionando

Pueden ver este sitio corriendo en soundstore.cloudapp.net

Mucha de la info mostrada se basa en el post Running ASP.NET 5 applications in Linux Containers with Docker de Ahmet Alp Balkan.

miércoles, 3 de diciembre de 2014

Universal PredicateBuilder... tunned for Azure AD Graph API queries

Las consultas a la Azure AD Graph API no admiten le sean provistos valores nulos o vacíos, y las opciones de filtro soportadas al día de hoy se limitan a and, or, eq, ge, le, Startswith, y Any.

La Microsoft Azure Active Directory Graph Client Library facilita notablemente el manejo de estas consultas desde las aplicaciones .NET, pero aún es algo incomodo la construcción dinámica de predicados, debido a lo cual recurrí para esta labor al PredicateBuilder generosamente compartido por Pete Montgomery allá por febrero del 2011.

Afortunadamente todo el entorno de Microsoft Azure está evolucionando rápidamente así que es de esperar estas limitaciones no perduren por mucho tiempo, pero comparto esta pequeña solución por si algún otro desarrollador se encuentra ante la misma situación.

Los ajustes introducidos a la versión de Pete fueron mínimos, y solo para asegurar la compatibilidad con los operadores lógicos and y or (Pete usó AndAlso, y OrElse, no soportados por la Graph API).

Consulta de usuarios

Basada en AzureADSamples/ConsoleApp-GraphAPI-DotNet

    IPagedCollection<IUser> searchResults = null;

    var predicate = GraphAPIPredicateBuilder.Create<IUser>(u => u.AccountEnabled == true);
    if (!string.IsNullOrWhiteSpace(canonicalUser.Name))
        predicate = predicate.And(u => u.UserPrincipalName.StartsWith(canonicalUser.Name));
    if (!string.IsNullOrWhiteSpace(displayname))
        predicate = predicate.And(u => u.DisplayName.StartsWith(displayname));
    if (!string.IsNullOrWhiteSpace(description))
        predicate = predicate.And(u => u.GivenName.StartsWith(givenname));

    try
    {
        ActiveDirectoryClient activeDirectoryClient =
            AzureADAuthenticationHelper.GetActiveDirectoryClientAsApplication();
        IUserCollection userCollection = activeDirectoryClient.Users;
        searchResults = userCollection.Where(predicate).ExecuteAsync().Result;
    }
    catch (Exception e)
    {
        Debug.WriteLine(string.Format("Error searching users - {0} {1}", e.Message,
            e.InnerException != null ? e.InnerException.Message : ""));
    }


GraphAPIPredicateBuilder


    /// <summary>
    /// Enables the efficient, dynamic composition of query predicates... tunned for Azure AD Graph API
    /// 
    /// Based on the work of Pete Montgomery at February 10, 2011
    /// http://petemontgomery.wordpress.com/2011/02/10/a-universal-predicatebuilder/
    /// </summary>
    public static class GraphAPIPredicateBuilder
    {
        /// <summary>
        /// Creates a predicate that evaluates to true.
        /// </summary>
        public static Expression<Func<T, bool>> True<T>() { return param => true; }

        /// <summary>
        /// Creates a predicate that evaluates to false.
        /// </summary>
        public static Expression<Func<T, bool>> False<T>() { return param => false; }

        /// <summary>
        /// Creates a predicate expression from the specified lambda expression.
        /// </summary>
        public static Expression<Func<T, bool>> Create<T>(Expression<Func<T, bool>> predicate) { return predicate; }

        /// <summary>
        /// Combines the first predicate with the second using the logical "and".
        /// </summary>
        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
        {
            return first.Compose(second, Expression.And);
        }

        /// <summary>
        /// Combines the first predicate with the second using the logical "andAlso".
        /// </summary>
        public static Expression<Func<T, bool>> AndAlso<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
        {
            return first.Compose(second, Expression.AndAlso);
        }

        /// <summary>
        /// Combines the first predicate with the second using the logical "or".
        /// </summary>
        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
        {
            return first.Compose(second, Expression.Or);
        }

        /// <summary>
        /// Combines the first predicate with the second using the logical "orElse".
        /// </summary>
        public static Expression<Func<T, bool>> OrElse<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
        {
            return first.Compose(second, Expression.OrElse);
        }

        /// <summary>
        /// Negates the predicate.
        /// </summary>
        public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expression)
        {
            var negated = Expression.Not(expression.Body);
            return Expression.Lambda<Func<T, bool>>(negated, expression.Parameters);
        }

        /// <summary>
        /// Combines the first expression with the second using the specified merge function.
        /// </summary>
        static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)
        {
            // zip parameters (map from parameters of second to parameters of first)
            var map = first.Parameters
                .Select((f, i) => new { f, s = second.Parameters[i] })
                .ToDictionary(p => p.s, p => p.f);

            // replace parameters in the second lambda expression with the parameters in the first
            var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);

            // create a merged lambda expression with parameters from the first expression
            return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);
        }

        class ParameterRebinder : ExpressionVisitor
        {
            readonly Dictionary<ParameterExpression, ParameterExpression> map;

            ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
            {
                this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
            }

            public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
            {
                return new ParameterRebinder(map).Visit(exp);
            }

            protected override Expression VisitParameter(ParameterExpression p)
            {
                ParameterExpression replacement;

                if (map.TryGetValue(p, out replacement))
                {
                    p = replacement;
                }

                return base.VisitParameter(p);
            }
        }
    }


That's all folks!


lunes, 27 de octubre de 2014

Encriptando una sección del web.config para Azure

Si bien el archivo web.config no es expuesto por el IIS, la presencia de información sensible en la sección appSettings de un proyecto Cloud Service de Microsoft Azure me llevó a buscar la posibilidad de encriptarlo local, y poder usarlo sin problemas en la nube.

Y lo que encontré fue esto:

Paso 1 - Necesito un certificado


Como mi proyecto ya estaba configurado para utilizar SSL lo que hice fue reutilizar el mismo certificado autofirmado.

Si no tenes un certificado hay que agregar uno al proyecto siguiendo los pasos descritos en Configuring SSL for an application in Azure (solo los pasos Get an SSL certStep 1: Get an SSL certificate, y la parte de upload certificate del paso Upload to AzureStep 3: Upload the deployment package and certificate).

Paso 2 - Agregar PKCS12ProtectedConfigurationProvider al WebRole desde Nuget



En el caso del Cloud Service solo basta con agregar este paquete al WebRole.

Paso 3 - Configurar el proveedor de ProtectedData en el web.config


Agregar la sección configProtectedData dentro de configuration del web.config, reemplazando el thumbprintValue por el del certificado usado.
<configuration>
  <configProtectedData>
    <providers>
      <add name="ProtectedConfigurationProvider" thumbprint="thumbprintValue" type="Pkcs12ProtectedConfigurationProvider.Pkcs12ProtectedConfigurationProvider, PKCS12ProtectedConfigurationProvider, Version=1.0.0.0, Culture=neutral, PublicKeyToken=34da007ac91f901d"/>
    </providers>
  </configProtectedData>
  ...
</configuration>

Paso 4 - Encriptar la sección del web.config que se quiere proteger


En este caso solo buscaba encriptar la sección appSettings, pero se puede hacer lo mismo con cualquier otra sección, o varias.
aspnet_regiis -pef appSettings "C:\source\Azure\DevDay\WebRole1" -prov ProtectedConfigurationProvider
Como acertadamente anticipa Alp Arslan Eren en su blog, si ejecutando el aspnet_regiis te encontrás con un error could not load the PKCS12ProtectedConfigurationProvider assembly como me pasó a mí, siguiendo estas indicaciones se soluciona.

Y si, para armar el tutorial usé el proyecto DevDay 2014 que tan gentilmente cedió la gente de Microsoft para el concurso de AR-UY... ;-)

Paso 5 - Insertar el gacutil como parte de nuestro proyecto


Antes de poder usar la PKCS12ProtectedConfigurationProvider.dll en Azure vamos a necesitar registrarla en la GAC, y dado que los WebRoles de Azure no se están incluyendo las Microsoft SDKs tendremos que llevarnos una copia del gacutil.exe y config hacia la nube.

En mi caso levanté el Cloud Service sobre Windows Server 2012, así que me copie ambos archivos gacutil desde la carpeta C:\Program Files (x86)\Microsoft SDKs\Windows\v8.1A\bin\NETFX 4.5.1 Tools a una nueva carpeta Startup dentro de mi proyecto WebRole1.


Paso 6 - Nueva Startup Task para ejecutar gacutil


Al desplegar el WebRole en Azure necesitamos que se ejecute gacutil como uno de los primeros pasos. Para eso agregamos un archivo RegisterGAC.cmd (salvar este archivo de con codificación ANSI), a la carpeta Startup recientemente creada, conteniendo el comando:
Startup\gacutil.exe /nologo /i PKCS12ProtectedConfigurationProvider.dll
..y un nuevo Startup Task dentro del WebRole al archivo ServiceDefinition.csdef de la solución:
<WebRole name="WebRole1" vmsize="Small">
  <Startup>
    <Task commandLine="Startup\RegisterGAC.cmd" executionContext="elevated" taskType="simple"/>
  </Startup>
  ...
</WebRole>
Los tres archivos agregados en la carpeta Startup deben quedar marcados como Copiar en el directorio de salida: Copiar siempre.

Paso 7 - Desplegar la solucion en Azure


...y observar como la aplicación fluye gloriosa!


Fuentes: