Automatizando nuestras tareas en Azure

Un gran número de las tareas que hacemos a diario probablemente pueden ser automatizadas evitándonos de esta manera perder unos minutos u horas que podríamos dedicar a otras cosas. En Azure, alguno de estos ejemplos son: parar nuestras máquinas por las noches cuando no están siendo usadas, desplegar un nuevo servicio, comprobar que nuestra aplicación está funcionando correctamente, etc.

Antes de la entrada en marcha de Azure Automation esto lo podíamos lograr a través de las herramientas de PowerShell para Azure ejecutándolas desde nuestro equipo local. Sin embargo, el problema era que teníamos que programar las tareas en nuestro sistema operativo y dejar nuestro equipo encendido para que se ejecutara correctamente.

Con Azure Automation logramos que esos dos problemas desaparezcan gracias a la ejecucción de nuestros scripts directamente en la nube con las capacidades que nos ofrece el servicio. Vamos a ver cómo usarlo.

Primeros pasos con Azure Automation

Para hacer uso del servicio de automatización el primer paso es disponer de una cuenta donde alojaremos la información necesaria para nuestros procesos de automatización como scripts, credenciales, variables, conexiones, etc.

Para crear una nueva deberemos acceder al Portal de Gestión > Automatización > Crear una cuenta de automatización

Creación de una cuenta de automatización
Creación de una cuenta de automatización

Tendremos que elegir un nombre para la cuenta de almacenamiento y una región. A día de hoy están disponibles tres regiones: Este de EEUU, Oeste de Europa y Sudeste de Asia. Por proximidad escogeremos Oeste de Europa.

El servicio se basa en el uso de “runbooks”, un concepto similar al de los script que podemos ejecutar en nuestros equipos. Los runbooks se basan en las capacidades de flujos de trabajo de PowerShell incorporadas en la versión 3.0

Para facilitar el proceso existe una galería de runbooks predefinidos que podemos utilizar como base para construir los nuestros propios. Podemos encontrarlos en Nuevo > Servicios de Aplicación > Automatización > Runbook > De la galería

Creación de un runbook de la galería
Creación de un runbook de la galería

A día de hoy existen 123 ejemplos disponibles para utilizar. Escogeremos dentro de la sección de destacados el de “Hello World for Azure Automation”. El asistente en el siguiente paso nos muestra el contenido del runbook antes de ir a la última pantalla donde definiremos el nombre de nuestro runbook, sobre qué cuenta queremos que se guarde y nuestra suscripción. Los datos por defecto son una buena opción.

Especificar detalles del runbook
Especificar detalles del runbook

Ejecutando nuestro primer runbook

Tras terminar los pasos anteriores tendremos disponibles nuestro runbook dentro de nuestra cuenta de automatización.

Write-HelloWorld runbook
Write-HelloWorld runbook

Si lo seleccionamos entraremos en las opciones específicas de dicho runbook. Seleccionamos la pestaña de AUTOR, donde se mostrarán los detalles del mismo y pulsamos en la barra inferior la opción de PRUEBA. Esto iniciará el proceso de ejecución de nuestro flujo de trabajo y nos pedirá que introduzcamos los parámetros necesarios. Si aceptamos la configuración que nos ofrece por defecto con el valor de World obtendremos una salida como la siguiente.

Resultado ejecución del runbook
Resultado ejecución del runbook

Con esto habremos ejecutado nuestra primera tarea automatizada con Azure Automation. La verdad es que no es nada sorprendente pero es el punto inicial para empezar a construir los runbooks que necesitamos. Si revisamos el código tenemos que:

 
workflow Write-HelloWorld {
    param (
 
        # Optional parameter of type string. 
        # If you do not enter anything, the default value of Name 
        # will be World
        [parameter(Mandatory=$false)]
        [String]$Name = "World"
    )
        Write-Output "Hello $Name"
}

EN este runbook estamos definiendo un nuevo flujo de trabajo llamado Write-HelloWorld. Tras ello, gracias a la función param definimos el parámetro $Name del tipo String con un valor por defecto y le marcamos con el atributo de opcional. En el último paso se ejecuta el comando que escribe por pantalla el mensaje de saludo y finaliza.

Desplegando una aplicación ASP.Net vNext en un contenedor de Docker

Resumiendo hasta la fecha hemos visto lo siguiente:

  1. Instalando el motor de Docker en una máquina virtual en Azure
  2. Instalando el cliente de Docker en Windows
  3. Conexión entre el cliente y servidor de Docker desplegados de forma manual en Azure
  4. Configurando Docker para acceso a través de HTTPs

Por lo tanto, ya sólo nos queda mostrar cómo desplegar alguna aplicación en un contenedor dentro de la instancia de Docker que tenemos ejecutándose en Azure. Podríamos probar con un simple comando imprimiendo un “Hola Mundo” pero aprovechando que de versiones alfa anda el juego, vamos a desplegar una aplicación ASP.Net vNext que tras los últimos anuncios ya es posible ejecutarlo en entornos Mac OSX y Linux también.

Obteniendo nuestra aplicación de ejemplo

En primer lugar vamos a buscar la aplicación de ejemplo que queremos desplegar. Podríamos escribirla nosotros mismos desde cero o, por el contrario, optimizar el tiempo y hacer uso de alguno de los ejemplos disponibles. Si accedemos al repositorio de GitHub del equipo de ASP.Net veremos que tenemos disponible el código fuente. Dentro de los ficheros existe la carpeta de Samples donde tenemos tres ejemplos de aplicación. De todos ellos, usaremos el de HelloMVC.

Para descargarlo tenemos dos opciones, descargar el fichero .zip disponible en GitHub con todo el código fuente del repositorio o clonar el repositorio con el siguiente comando:

git clone https://github.com/aspnet/Home.git

Tanto con una opción como con la otra tendremos en nuestro ordenador una copia de los ficheros que necesitamos.

Preparando la imagen de Docker

A la hora de configurar nuestra imagen para ser ejecutada en el contenedor podemos seguir dos caminos: realizarlo de forma manual o utilizar un fichero específico, DockerFile , para que Docker lo haga por nosotros. En esta ocasión emplearemos esta segunda opción para simplificar el proceso.

Lo primero será crear nuestro fichero DockerFile. Lo podemos hacer directamente desde nuestro bloc de notas. Dentro de él iremos definiendo los pasos necesarios para desplegar nuestra aplicación.

Desde Microsoft se ha preparado una imagen base que se puede emplear como plantilla para generar las nuestras propias. Está disponible en el repositorio bajo el nombre microsoft/aspnet . Esta imagen se encarga de configurar todos los elementos necesarios para tener un entorno de ASP.Net vNext. Si tenemos curiosidad podemos ver el contenido de su DockerFile.

Por lo tanto, la primera línea de nuestro DockerFile será la siguiente.

FROM microsoft/aspnet

Tras ello, necesitaremos copiar los ficheros que forman nuestra aplicación web dentro del contenedor. A día de hoy la versión alfa del cliente de Windows para Docker no gestiona correctamente las rutas de ficheros, es necesario pararlo como un fichero comprimido. Por ello, comprimiremos nuestra carpeta HelloMVC en formato .tar con 7-Zip. El comando ADD es capaz de reconocer los ficheros .tar entre otros y descomprimirlos. Además de copiarlos, a continuación navegaremos dentro de la carpeta app para continuar con la configuración de la imagen.

Traducido lo anterior a nuestro DockerFile quedaría como lo siguiente.

ADD HelloMvc.tar /app/
WORKDIR app

Una vez que tenemos nuestra aplicación copiada necesitamos restaurar las dependencias con los paquetes de NuGet que tiene. Esto lo permite gestionar el comando kpm que se incluye con ASP.Net vNext. En nuestro DockerFile necesitaremos incorporar lo siguiente.

RUN kpm restore

Por último necesitamos exponer un extremo de nuestro contenedor a través del cual accederemos a nuestra aplicación web y configurar la image para que al ser ejecutada inicialice el servidor web de ASP.Net vNext: k. Por lo tanto, las últimas líneas de nuestro DockerFile serán las siguientes.

EXPOSE 5004
ENTRYPOINT ["k", "kestrel"]
DockerFile para nuestra aplicación ASP.Net vNext
DockerFile para nuestra aplicación ASP.Net vNext

El último paso será construir nuestra imagen. Para el comando siguiente suponemos que nuestro fichero DockerFile y HelloMVC.tar se encuentran dentro de nuestra carpeta HelloMVC.

Carpeta de ejemplo de la aplicación
Carpeta de ejemplo de la aplicación

Si no es así tendremos que adaptar el siguiente comando para que se ajuste a nuestra ruta. De todo el comando, la última parte es la que nos interesa, lo otro únicamente define los parámetros de la conexión usando HTTPs como mencionaba en el artículo anterior.

docker.exe --tlsverify --tlscacert="C:\Users\jangelfdez\Desktop\ca-public-key.pem" --tlscert="C:\Users\jangelfdez\Desktop\client-cert.pem" --tlskey="C:\Users\jangelfdez\Desktop\client-private-key.pem" -H=jangelfdez.cloudapp.net:2376 build -t myaspnetvnextapp samples\HelloMvc

Tras ello nuestra imagen comenzará a obtener los ficheros que necesita de forma automática. Esperaremos hasta que termine antes de continuar.

Creación de nuestra imagen personalizada para ASP.NET vNext
Creación de nuestra imagen personalizada para ASP.NET vNext

Una vez que haya finalizado solo nos quedará ejecutar la imagen dentro de un contenedor y nuestro sitio web estará disponible.

docker.exe --tlsverify --tlscacert="C:\Users\jangelfdez\Desktop\ca-public-key.pem" --tlscert="C:\Users\jangelfdez\Desktop\client-cert.pem" --tlskey="C:\Users\jangelfdez\Desktop\client-private-key.pem" -H=jangelfdez.cloudapp.net:2376 run -d -t -p 8080:5004 myaspnetvnextapp
Aplicación ASP.Net vNext ejecutándose en contenedor de Docker
Aplicación ASP.Net vNext ejecutándose en contenedor de Docker

Configurando Docker para acceso a través de HTTPs

Comentaba en el artículo anterior que activar el extremo de escucha HTTP en Docker para que otras máquinas de la red pudieran acceder al motor no era una buena práctica. Esto se debe a que al habilitarlo estamos dando acceso a cualquier persona que conozca la combinación de IP y puerto donde tenemos nuestra instancia de Docker en ejecución. Para protegerlo será necesario configurar Docker para que haga uso de la conexión a través de HTTPs.

El proceso de configuración no es trivial ya que lleva involucrado la creación de certificados para el servidor y los diferentes clientes que se conecten. Gracias a ellos, es posible establecer una relación de confianza entre ambos extremos de la conexión y así, en el caso de que otra persona se intente conectar sin disponer de los certificados correctos, el motor de Docker rechazará la conexión. Para crearlos necesitaremos trabajar con OpenSSL dentro de nuestra máquina con Linux.

A la hora de trabajar con sistemas de clave pública es necesario tener mucho cuidado en la configuración y gestión de su información como las claves privadas. Este artículo no entra en detalles de cómo montar una buena solución basada en OpenSSL, únicamente emplea los elementos necesarios para mostrar la configuración del acceso por HTTPs en Docker

Tras esta pequeña advertencia comenzamos.

Creando nuestra entidad certificadora

Para tener un poco ordenada la información relacionado con este proceso de generar los certificados trabajaremos con un directorio a nivel local de nuestro usuario. Dentro del mismo, crearemos varias subcarpetas para guardar los diferentes ficheros involucrados ref. En la primera guardaremos los certificados emitidos, en la segunda las peticiones para generar nuevos certificados, en la tercera la lista de revocación de certificados y por último, la que contendrá la información privada de nuestra CA. Necesitaremos protegerla para evitar el acceso por otros usuarios.

mkdir -p $HOME/CA/{certsdb,certreqs,crl,private}
chmod 700 CA/private

En el siguiente paso, crearemos los dos ficheros necesarios por nuestra entidad certificadora. El fichero index.txt es empleado por OpenSSL para llevar un listado de los certificados firmados y el fichero ca.srl los números de serie. Ambos forman la base de datos de nuestra entidad.

cd CA
echo "01" > ca.srl
touch index.txt

Tras ello, generaremos nuestra clave RSA privada de tamaño 2048 bits. Durante el proceso nos pedirá la clave de paso que queremos usar para protegerla.

openssl genrsa -des3 -out "CA/private/ca-private-key.pem" 2048
Configurando la entidad certificadora para Docker
Configurando la entidad certificadora para Docker

El siguiente paso será obtener la clave pública de nuestra entidad certificadora. Los campos que nos piden los podemos completar con nuestra información correcta o no, según deseamos. El que será importante será el definir el FQDN de nuestro servidor.

openssl req -new -x509 -days 365 -key "CA/private/ca-private-key.pem" -out "CA/private/ca-public-key.pem"
Configurando la entidad certificadora para Docker
Configurando la entidad certificadora para Docker

Generando el certificado para el servidor

Una vez que hemos terminado con nuestra entidad certificadora nos toca configurar ahora el certificado para nuestro motor de Docker. Para ello, tendremos que generar una nueva clave privada de forma similar a lo que hemos hecho anteriormente. Necesitaremos introducir una nueva clave de paso para protegerla.

openssl genrsa -des3 -out "CA/private/server-private-key.pem" 2048

Una vez que la tenemos el siguiente paso es solicitar una petición de firma de nuestro certificado, también conocido como Certificate Signing Request . Es muy importante sustituir el parámetro CN, Common Name, por el nombre del servidor al que nos conectaremos. En mi caso será jangelfdez.cloudapp.net. Será necesario introducir la clave que hemos definido en el paso anterior.

openssl req -subj '/CN=jangelfdez.cloudapp.net' -new -key "CA/private/server-private-key.pem" -out "CA/certreqs/server.csr"

Tras haber hecho la solicitud el siguiente paso es firmar nuestra clave por nuestra entidad certificadora. Para ello, ejecutamos lo siguiente.

openssl x509 -req -days 365 -in "CA/certreqs/server.csr" -CA "CA/private/ca-public-key.pem" -CAkey "CA/private/ca-private-key.pem" -CAserial "CA/ca.srl" -out "CA/certsdb/server-cert.pem"
Configurando la entidad certificadora para Docker
Configurando la entidad certificadora para Docker

Generando el certificado para el cliente

Este proceso será muy parecido al del apartado anterior, la única diferencia será que necesitaremos configurar una de las extensiones del certificado para que permita ser utilizado para autenticación. Por lo tanto, comenzamos creando la clave privada y generando la petición de firma de nuestro certificado.

openssl genrsa -des3 -out "CA/private/client-private-key.pem" 2048
openssl req -subj '/CN=client' -new -key "CA/private/client-private-key.pem" -out "CA/certreqs/client.csr"

Una vez que lo tenemos, configuramos la extensión para autenticación. Únicamente será necesario definir una pareja clave-valor y pasarle el fichero a la hora de firmar la petición.

echo extendedKeyUsage = clientAuth > extfile.cnf
openssl x509 -req -days 365 -in "CA/certreqs/client.csr "CA/private/ca-public-key.pem" -CAkey "CA/private/ca-private-key.pem" -CAserial "CA/ca.srl" -out "CA/certsdb/client-cert.pem" -extfile extfile.cnf

Configurando Docker para hacer uso de HTTPs

La parte complicada ya la hemos terminado, ahora necesitaremos dos cosas más antes de tener listo el acceso por HTTPs. En primer lugar, eliminar la frase de paso de las claves de nuestro cliente y servidor.

openssl rsa -in "CA/private/server-private-key.pem" -out "CA/private/server-private-key.pem"
openssl rsa -in "CA/private/client-private-key.pem" -out "CA/private/client-private-key.pem"

Tras ello, arrancamos nuestro motor de Docker pasándole los parámetros que especifican su certificado y clave correspondiente.

docker -d --tlsverify --tlscacert="CA/private/ca-public-key.pem" --tlscert="CA/certsdb/server-cert.pem" --tlskey="CA/private/server-private-key.pem" -H=0.0.0.0:2376
Ejecutando Docker con HTTPs
Ejecutando Docker con HTTPs

El servidor ya está configurado correctamente para aceptar únicamente peticiones a través de HTTPs y que se autentiquen con un certificado firmado por nuestra autoridad certificadora en el puerto 2376. Por lo tanto, faltará a nuestro cliente indicarle que queremos utilizar este tipo de autenticación lanzándolo con los siguientes parámetros.

docker.exe --tlsverify --tlscacert="C:\Users\jangelfdez\Desktop\ca-public-key.pem" --tlscert="C:\Users\jangelfdez\Desktop\client-cert.pem" --tlskey="C:\Users\jangelfdez\Desktop\client-private-key.pem" -H=jangelfdez.cloudapp.net:2376 info

Y con ello tendremos nuestro cliente desde Windows 10 conectado a nuestro motor de Docker a través de HTTPs.

Cliente de Windows de Docker conectado por HTTPs
Cliente de Windows de Docker conectado por HTTPs

Conexión entre el cliente y servidor de Docker desplegados de forma manual en Azure

En los dos artículos anteriores hemos visto en primer lugar cómo desplegar el motor de Docker en una máquina virtual desplegada en Azure de forma manual; en segundo lugar, cómo configurar el cliente de Docker en Windows con la primera versión de prueba del mismo en un Windows 10 que también está desplegado en Azure. Ambas máquinas se encuentra dentro de la misma red virtual de Azure, un entorno similar al que tendríamos en local si estuviéramos utilizando Hyper-V; por ejemplo, para montar este entorno de pruebas.

El siguiente paso consiste en probar la comunicación entre ambos extremos. Por defecto, Docker escucha las conexiones entrantes a través del siguiente socket unix:///var/run/docker.sock. La única conexión permitida será a nivel local accediendo con el usuario root. Sin embargo, para hacer esta prueba rápida vamos a ver cómo modificarlo para que escuche en un puerto TCP y nos podamos conectar desde otras IPs.

Es muy importante tener en cuenta que esto habilita el acceso a nuestro motor de Docker a cualquier persona que conozca la combinación de IP y puerto, por ello no lo debemos realizar nunca fuera de entornos de prueba.

Para ello, lanzaremos el demonio de Docker pasánadole el parámetro -H donde especificaremos que escuche a través de TCP en el puerto que le indiquemos.

$ sudo docker -H 0.0.0.0:2375 -d &
Arrancando el motor de Docker
Arrancando el motor de Docker

Ahora, podremos conectarnos desde nuestro cliente Windows y mostrar la información de nuestro servidor:

Cliente de Docker en Windows
Cliente de Docker en Windows

Lo siguiente será configurarlo utilizando HTTPs para permitir la conexión segura desde otros equipos fuera de la red local como el ordenador en mi oficina y el servidor desplegado en Azure.

Instalando el cliente de Docker en Windows

La firma del acuerdo colaboración entre Docker y Microsoft anunciada a mediados de octubre de este año va a traer dos piezas importantes de Docker a los entornos Windows. En primer lugar, la disponibilidad del engine de Docker en Windows Server para poder desplegar contenedores de una forma similar a la que se realizar a día de hoy en Linux/Unix. Y en segundo, la disponibilidad del cliente de Docker para Windows con lo que no necesitaremos ya soluciones como Boot2Docker para trabajar con él.

El trabajo de implementación ha empezado y ya podemos ver los primeros resultados: la disponibilidad de las herramientas de línea de comandos para Docker en nuestro sistema operativo Windows. Vamos a ver cómo podemos instalar el cliente sobre una máquina con Windows 10 en este caso.

En primer lugar necesitaremos tener instalado en nuestra máquina Go, el lenguaje de programación. Si no lo tenemos, desde la página del proyecto podemos descargarnos el instalador para Windows y completar este primer paso.

Descargar instalador Go
Descargar instalador Go

Una vez que lo tengamos, necesitamos comprobar que funciona de forma correcta ejecutando el comando go en nuestra consola.

Go ejecutado desde PowerShell
Go ejecutado desde PowerShell

Tras ello, necesitaremos Git para podernos descargar el código fuente del cliente y proceder a compilarlo en nuestra máquina. Si no lo tienes disponible, también podemos bajarlo desde la página oficial de Git.

Instalación de Git para Windows
Instalación de Git para Windows

Una vez que lo tengamos, comprobaremos también que funciona correctamente.

Git ejecutándose en Windows
Git ejecutándose en Windows

Tras cumplir con los dos requisitos previos ya estamos preparados para obtener el código y compilarlo. Para ello, clonaremos el repositorio de Docker disponible de forma pública en GitHub.

git clone https://github.com/docker/docker.git c:\go\src\github.com\docker\docker
Clonando repositorio de Docker
Clonando repositorio de Docker

Una vez clonado, configuramos las siguientes variables de entorno para definir dónde se puede encontrar el compilador de Go y activar la flag del proceso de compilación que sólo habilitará el proceso que genera la parte cliente de Docker. A día de hoy no existe aún la parte de servidor.

set GOPATH=c:\go;c:\go\src\github.com\docker\docker\vendor
set DOCKER_CLIENTONLY=1
cd c:\go\src\github.com\docker\docker\docker
go build -v
Compilando el cliente de Docker en Windows
Compilando el cliente de Docker en Windows

Si has seguido todos los pasos de forma correcta ya tendrás disponible tu cliente de Docker en Windows para empezar a trabajar con él de forma similar a como lo realizas ya en Linux/Unix.

Cliente de Docker ejecutándose en Windows
Cliente de Docker ejecutándose en Windows

Instalando el motor de Docker en una máquina virtual en Azure

Docker se está convirtiendo en la plataforma escogida por muchos desarrolladores y administradores de sistemas para desarrollar, desplegar y ejecutar sus aplicaciones basadas en entornos Linux/Unix. Permite disponer de forma rápida de un entorno o contenedor virtual que aísla nuestra aplicación del sistema operativo. Es un nivel de virtualización o abstracción superior al que estamos acostumbrados con los hipervisores y las máquinas virtuales. Para más detalles, es posible consultar la documentación de Docker.

Si queremos trabajar con Docker en Azure tenemos dos formas de hacerlo. Realizar la configuración del motor de forma manual o emplear las extensiones para máquinas virtuales disponibles en Azure. Vamos a ver cómo realizarlo de las dos formas:

Instalación manual del motor de Docker

El propio sistema de repositorios de paquetes de Ubuntu, distribución sobre la que haremos la configuración, dispone de un paquete de Docker listo para instalar: docker.io. Sin embargo, es posible que el paquete no nos instale la última versión disponible. Por ejemplo, a día de hoy el paquete tiene la versión 1.0.1 mientras que Docker va por la versión 1.4.1

Docker.io versión repositorio
Docker.io versión repositorio

Como nos interesa tener la última versión vamos a realizar de forma manual la configuración. Para ello, haremos uso del propio repositorio de Docker que está disponible:

  1. Añadimos la clave del repositorio de Docker a nuestro equipo
    sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9
  2. Añadimos ahora el repositorio a nuestro listado de fuentes
    sudo sh -c "echo deb https://get.docker.com/ubuntu docker main\ > /etc/apt/sources.list.d/docker.list"
  3. Actualizamos para coger los cambios e instalamos el paquete lxc-docker
    sudo apt-get update
    sudo apt-get install lxc-docker

Podemos ver que la instalación se ha completado correctamente comprobando la versión disponible instalada.

Instalación de Docker
Instalación de Docker

Tenemos que tener en cuenta que es necesario configurar el extremo de Docker si queremos acceder desde el exterior y configurar el acceso por HTTPs si nos interesa proteger nuestra instalación.

Instalación a través de la extensión de Docker para máquinas virtuales

Si no queremos hacerlo de forma manual, Azure incluye soporte a Docker como una extensión que se puede añadir de forma automática nuestra máquina virtual. Para ello, una vez que tenemos nuestra máquina virtual con Ubuntu desplegada, accedemos al nuevo portal de Azure

  1. Accedemos a Examinar > Máquinas virtuales y escogemos nuestra máquina virtual

    Máquina virtual con Ubuntu en Azure
    Máquina virtual con Ubuntu en Azure
  2. Seleccionamos la opción de extensiones y tras ello, en la nueva hoja que se abre, hacemos click en Agregar

    Configuración de extensiones en Azure
    Configuración de extensiones en Azure
  3. De las tres disponibles escogeremos la que nos interesa, la de Docker. En la nueva hoja seleccionaremos Crear y a continuación completaremos el asistente con los ficheros que nos solicita para acceder a través de HTTPs.
    Seleccionar la extensión de Docker
    Seleccionar la extensión de Docker

Con ello tendremos nuestro motor de Docker listo.

Instalación de Docker
Instalación de Docker

Ahora ya podemos trabajar :)

Obteniendo la última versión del módulo de PowerShell de Azure

El ritmo de evolución que tienen las soluciones en la nube es abrumador, en cuanto te despistas por un momento nuevos productos y funcionalidades están disponibles. Esto es algo que a los que estamos acostumbrados a trabajar con Azure nos pasa, sólo hay que ver los últimos cambios en el portal de actualizaciones de los diferentes servicios.

Estas nuevas funcionalidades y servicios obligan a actualizar al mismo tiempo las herramientas de gestión. En mi caso, suelo trabajar con Azure a través de PowerShell. Si vosotros queréis trabajar con lo mismo, es posible instalar el módulo de dos formas diferentes: haciendo uso del Web Platform Installer o descargándote el instalador en un fichero .msi. Aunque el WebPI es muy útil para poner a punto tu equipo con todas las herramientas necesarias si trabajas con entornos web, yo prefiero gestionar directamente la instalación del módulo de PowerShell y no tener un programa intermedio que lo haga.

La forma manual de obtener la última versión es la siguiente:

  1. Acceder al portal de GitHub del equipo de Azure donde se encuentra el repositorio de las herramientas de PowerShell
  2. Localizar la opción de ver las últimas versiones públicas
  3. Seleccionar la instalación “Windows Standalone” y descargar el fichero
  4. Lanzar la instalación desde el fichero .msi

El proceso es siempre el mismo por lo que nos da juego a que lo automaticemos con un pequeño script de PowerShell para que lo haga por nosotros. Para obtener los datos necesarios haremos uso de la API que GitHub tiene disponible de forma pública. En particular, haremos uso de la opción de listar las versiones disponibles en un repositorio.

Vamos a ver cómo realizarlo de forma automática

En primer lugar necesitaremos saber cuál es la versión que tenemos disponible del módulo en nuestro PC; en el caso de que no haya ninguna finalizaremos el script ya que no tendremos versión con la que comparar para actualizarlo o no. Otra opción sería ofrecer directamente la descarga aunque no está implementado.

# Check the actual version of the Azure Powershell module if its available
$azureModule = Get-Module -ListAvailable | Where { $_.Name -eq "Azure"}
if ($azureModule -eq $null )
{
    Write-Output "Microsoft Azure PowerShell module is not available on your computer"
    Return
}
$azureInstalledVersion = $azureModule.Version

Tras conocer cuál es la versión que tenemos instalada el siguiente paso es conocer cuál es la última que está disponible en el repositorio de GitHub. Realizaremos la consulta contra la API y en el caso de que esta no devuelva la información esperada finalizaremos la ejecución. Otra posible comprobación a añadir es que la llamada a la API se establece correctamente.

# Check the latest version of the Azure Powershell module released on GitHub
$gitHubData = Invoke-RestMethod -Method Get -Uri "https://api.github.com/repos/Azure/azure-powershell/releases" 
$latestRelease = $gitHubData | Select -First 1
 
if (![System.Version]::TryParse($latestRelease[0].name, [ref]$latestReleaseVersion) )
{
    Write-Error "Information about the latest version cannot be retrieved." -Category ConnectionError -CategoryReason "The connection to GitHub API has not been established properly and the information has not been retrieved"
    Return
}

Si ya estamos con la versión más reciente no necesitaremos continuar.

if ($azureInstalledVersion -ge $latestReleaseVersion)
{
    Write-Output "Your Microsoft Azure Powershell module version ($azureInstalledVersion) is greater or equal to the latest version ($latestReleaseVersion)."
    Return
}

Sin embargo, si tenemos una versión anterior ofreceremos la opción de actualizarse a la última descargando el fichero .msi disponible en la descripción de la release.

# Check if the user wants to update the module
Write-Output "Your Microsoft Azure Powershell module version ($azureInstalledVersion) is not the latest ($latestReleaseVersion)."
$updateModule = Read-Host "Do you want to update it? (Y/N)"
 
if ($updateModule -ne "Y")
{
    Return
}
Updating Azure PowerShell Module
Confirmación de actualización

Si aceptamos, automáticamente nos descargará el instalador y lo ejecutará por lo que nos encontraremos con la página de inicio del asistente para completar nuestra actualización:

$installerUrl = $latestRelease.body | Select-String -Pattern "\[Windows Standalone]\((http://.*)\)" | %{ ($_.Matches.Groups)[1].Value }
$savedFilePath = "$env:HOMEDRIVE$env:HOMEPATH\Downloads\azure-powershell.$($latestRelease.name).msi"
Invoke-WebRequest -Uri $installerUrl -OutFile $savedFilePath
 
Write-Output "Launching installer"
Invoke-Item $savedFilePath
Updating Azure PowerShell Module
Asistente de instalación del módulo de Azure

Si continuamos con el asistente tendremos actualizado finalmente nuestro módulo de Azure en el equipo.

Cómo instalar Ubuntu 14.04 en Hyper-V en una máquina de Generación 2

A la hora de estar preparando una serie de materiales para introducir Azure a los desarrolladores y administradores de sistemas que utilizan Linux en su día a día, he tenido que instalar una copia de Ubuntu sobre el Windows Server 2012 R2 que utilizo como máquina de trabajo habitual. Estos pasos son similares a si la instalación se realizará sobre Windows 8 o posterior ya que incluye el mismo hypervisor.

  1.  Accedemos a la página de Ubuntu para descargarnos la imagen .ISO. En el menú superior seleccionamos la opción de Descarga
    Ubuntu-HyperV-Gen2-Step1
  2. En este caso estaremos interesados en instalar la versión de escritorio por lo que seleccionamos Ubuntu Desktop
    Ubuntu-HyperV-Gen2-Step2
  3. Trabajaremos con la versión Ubuntu 14.04.1 LTS 64 bits por lo que podemos darle a Download directamente.
    Ubuntu-HyperV-Gen2-Step3
  4. Una vez que se ha terminado de descargar tendremos que crear una máquina virtual nueva. Para ello, abrimos el Hyper-V Manager y en el menú lateral seleccionamos New > Virtual Machine
    Ubuntu-HyperV-Gen2-Step4
  5. Elegimos el nombre de la máquina virtual
    Ubuntu-HyperV-Gen2-Step5
  6. Seleccionamos como tipo de máquina virtual la Generación 2 . Aunque en el mensaje informativo no se incluya es posible ejecutar Ubuntu en este nuevo tipo de máquinas virtuales y aprovecharnos de las ventajas respecto a la Generación 1. Únicamente será necesario modificar el uso de Secure Boot que viene activado por defecto. En un próximo paso lo cambiaremos.
    Ubuntu-HyperV-Gen2-Step6
  7. Seleccionamos la cantidad de memoria RAM que queremos asignar a la máquina y si deseamos utilizar Dynamic Memory o no.
    Ubuntu-HyperV-Gen2-Step7
  8. Configuramos el switch virtual que utilizará la máquina virtual para conectarse a la red. En este caso queremos conexión a Internet por lo que he seleccionado uno externo a través de la tarjeta inalámbrica.
    Ubuntu-HyperV-Gen2-Step8
  9. Seleccionamos el nombre y la capacidad de nuestro disco duro.
    Instalación Ubuntu en Hyper-V
  10. Indicamos que queremos instalar un nuevo sistema operativo a partir de la imagen ISO que hemos bajado e introducimos la ruta del fichero.
    Ubuntu-HyperV-Gen2-Step10
  11. Aceptamos el asistentes y en segundos nuestra máquina virtual estará creada.
    Ubuntu-HyperV-Gen2-Step11
  12. Ahora será el momento de modificar la configuración del Secure Boot para poder arrancar nuestra máquina sin problemas. Para ello seleccionamos nuestra máquina virtual en la pantalla central y en el menú lateral derecho del Hyper-V Manager la opción de Settings
    Ubuntu-HyperV-Gen2-Step12
  13. En la pestaña de Firmware deberemos de quitarle el tick al checkbox de Enable Secure Boot Tras ello aceptamos los cambios y salimos.
    Ubuntu-HyperV-Gen2-Step13
  14. Una vez finalizado los pasos anteriores arrancamos nuestra máquina virtual y podremos empezar la instalación seleccionando Install Ubuntu.
    Ubuntu-HyperV-Gen2-Step14
  15. Tras configurar todos los parámetros que nos indican tendremos nuestra máquina lista para trabajar.
    Ubuntu-HyperV-Gen2-Step16

Si tras finalizar la instalación tienes problemas de conectividad a la red puedes deberse a un problema con tu router inalámbrico si estás utilizando como yo tu tarjeta de red. En esta pregunta de Stack Overflow explican el motivo. También puedes realizar un cambio en la configuración del switch virtual como otra opción.

Preparar Visual Studio para Windows for IoT

Si ya has realizado los pasos previos que comentaba en el anterior post, lo siguiente es configurar nuestro entorno de desarrollo. Para ello, es necesario descargarse el ejecutable .msi disponible dentro de la plataforma Microsoft Connect.

WindowsDeveloperProgramForIoT

Es recomendable usar el enlace de descarga disponible dentro de la columna de “Descargar archivo único” en lugar de la opción de “Descargar” dentro del botón azul si no deseas usar el administrador de transferencia de ficheros. Dichero ejecutable incluye dos ficheros: Windows Developer Program For IoT MSI Content

 

  • GalileoWatcher.exe: es una utilidad para detectar la placa conectada a la red o al ordenador y extraer información básica de la misma como su dirección IP y su nombre.
  • Windows Developer Program for IoT.vsix: es la extensión de Visual Studio que añade soporte al desarrollo de proyectos basados en la placa galileo.

Para completar la instalación únicamente necesitas seguir el asistente que se abre cuando ejecutas el fichero .msi.

Install - Step 1

A continuación, saltará la UAC dos veces para que apruebes la instalación de la extensión y del otro programa.

Install - Step 2

Install - Step 3

Tras ello, solo tienes que abrir Visual Studio para tener listo tu proyecto C++ para comenzar con ello:

Install - Step 4

Otra herramienta que resultará útil es el cliente de Telnet para acceder de forma remota a nuestra placa y poder interactuar con ella. Para ello, únicamente necesitas seguir los siguientes pasos extraídos de la librería de TechNet:

  1. Haga clic en Inicio y, a continuación, haga clic en Panel de control.
  2. En la página Ventana principal del Panel de control, haga clic en Programas.
  3. En la sección Programas y características, haga clic en Activar o desactivar las características de Windows.
  4. Si aparece el cuadro de diálogo Control de cuentas de usuario, confirme que la acción que muestra es la que desea y, a continuación, haga clic en Continuar.
  5. En la lista Características de Windows, seleccione Cliente Telnet y, a continuación, haga clic en Aceptar

Ahora a seguir esperando por una placa para las pruebas. Por ahora, ya han comenzado a enviarlas

How to: Windows Developer program para IoT

Empezar a escribir algo siempre lleva una cierta resistencia, sobre todo cuando es con una pantalla en blanco y encima el artículo inicial del blog. Al final terminas dejándolo a un lado en busca del tiempo o la idea con la que ponerte a escribir. Creo que ese día llegó aprovechando el lanzamiento del programa para desarrolladores de Windows para el Internet de las Cosas, más conocido como el Internet of Things (IoT). En abril, en la primera keynote del Build se presentó esta nueva línea de trabajo para ofrecer la opción a los desarrolladores de poder hacer aplicaciones para esta nueva serie de dispositivos.

Sin embargo, no tiene por qué ser solo para desarrolladores. Aquellos como yo que les guste en el punto medio entre los cacharros de hardware y el software que los controla les va a resultar seguramente interesante. Rafa Serna escribía una muy buena introducción a lo que consistía Windows para el IoT. Con este artículo yo únicamente quería aclarar un poco qué pasos son necesarios para empezar a conocer más detalles de este nuevo sistema. La página clave es http://www.windowsondevices.com; sin embargo, a partir de ahí puede resultar más confuso qué es necesario realizar. Por lo tanto estos son los pasos:

  1. Seguro que quieres tener algo de hardware para probar. Si es así, accede a http://www.windowsondevices.com/signup.aspx para completar tu solicitud de una placa Intel Galileo. Hay más solicitudes que placas disponibles por lo que es posible que no todos podamos recibir una.
  2. Tras solicitar tu placa, lo siguiente es obtener el software necesario. Para ello, es necesario acceder a la plataforma Connect donde además también podrás proporcionar tus comentarios para mejorar el producto.
  3. Configura tu ordenador, tu placa Galileo y crea las primeras aplicaciones a través del portal disponible en GitHub
  4. ¿Tienes alguna duda o pregunta? A través de Twitter con el hashtag #winbuilder, los foros de MSDN o Stack Overflow puedes encontrar las respuestas

Y con esto, más o menos tendrías todo listo para empezar a trabajar con esta nueva plataforma. Ahora solo queda esperar que nos llegue una placa para probarlo.