Azure
Contenido
Introduccion
Mis pruebas con Azure
Usando la línea de comandos
Para usar la línea de comandos en Linux hace falta tener instalado nodejs y npm.
En Ubuntu
$ apt-get install nodejs npm
Cabe destacar que a diferencia de otras distros, el comando para ejecutar un nodejs no es "node", sino "nodejs". Para igual se puede crear un enlace simbólico
$ sudo ln -s /usr/bin/nodejs /usr/bin/node
Así algunos scripts .js podrán ser ejecutado sin en la primera línea del script está "#!/usr/bin/node"
La herramienta de azure se puede instalar con npm:
$ sudo npm install -g azure $ sudo npm install -g azure-cli
Login con el Cli
Hay varias formsa de hacer login en una cuenta Azure con el Cli, la más básica es a través de web:
$ azure login
Nos muestra un mensaje que nos indica navegar por una URL e introducir un código. Una vez hecho nos pide las credenciales con las que logarnos y automáticamente el CLI devuelve un OK. Con eso ya estamos logado durante un tiempo.
Eso creará en tu ~/.azure un fichero con las nuevas credenciales de sesión (temporales)
La otra forma es creando una app en nuestro AD. Los pasos seguidos son
- Creamos la app
$ azure ad app create -n ecitest --home-page http://www.elcorteingles.es --identifier-uris https://ecitest.com/home -p micontraseña
- Le asignamos un service principal a nuestra nueva AP
$ azure ad sp create --applicationId 71578ccd-ab8d-4e34-9e82-5600bef82e34
- Asignamos un rol a esta app
$ azure role assignment create --spn https://ecitest.com/home -o Contributor
Una vez hecho todo esto ya podemos usar esa app para logarnos:
$ azure login --service-principal -u https://ecitest.com/home -p micontraseña --tenant 0f9f0817-7763-49b7-8f53-311d68683e2d
Más información sobre como hacer login aqui [1]
Creando una VM
Esta fue mi primera prueba creando una VM
$ azure vm create --verbose --json --location "West Europe" -e 22 -n admin2 ardemans-admin2 -t ~/.ssh/pmblanco.pub.pem -P -w Main -b services 5112500ae3b842c8b9c604889f8753c3__OpenLogic-CentOS-72-20160308 pmblanco --custom-data "./test.sh"
La máquina se creó pero parece que no ejecutó el test.sh que enviaba en el custom-data. Parece que esto solo fucinoa si la imagen de la vm tiene cloud-init, y en el caso de azure esta solo viene con las imágenes de ubuntu.
Otra de las cosas extrañas que me ha pasado es que la máquina tiene IP pública pero parece que el dns se ha asociado a la IP interna, por lo menos durante los primeros instantes nada mas crear la vm.
ARM (azure resource management)
Pues resulta que tienen dos tipos de administracion, orientado a servicio y orentiado a recursos, y por ahí pone que recomiendan ir pasando a ARM. En esta página explican la diferencia.
Creando máquina en ARM
Grupo de recursos
Empiezo definiendo un grupo de recursos para agrupar lo que voy creando para esta prueba.
$ azure group create -v --json -n GroupOne -l "West Europe"
Redes
Las redes virtuales en las que voy a meter mi máquina.
$ azure network vnet create -v --json -g GroupOne -l "West Europe" -n main -a "172.1.0.0/16" -d 8.8.8.8
Cabe destacar que aunque lo meto en un grupo que ya tiene definido un "location", a la hora de crear la red tambien hay que especificar el parámetro -l, para decir donde tienes que crear la red. También hay que crear una subred dentro de la red que hemos definido
azure network vnet subnet create -g GroupOne -e main -n services -a "172.1.1.0/24"
Cuenta de almacenamiento
$ azure storage account create -v --json -l "West Europe" -g GroupOne --type LRS ardemansstorageone
Selecionando imagen a arrancar
Con el cli de azure podemos ver una lista de imagenes, organizadas por publishers. Para saber el código de una imagen primero tendremos que saber el código del publisher de la imagen que queremos buscar.
$ azure vm image list-publishers -l "West Europe"
Una vez sabemos el publisher podemos ver la lista de imagenes que ofrece:
$ azure vm image list -l "West Europe" -p OpenLogic
Creando una VM
Un ejemplo del comando usado para arrancar una vm
$azure vm create -v --json -g GroupOne -l "West Europe" -u "pmblanco" --ssh-publickey-file ~/.ssh/pmblanco.pub \ --nic-name eth10 --vm-size "Standard_A1" --vnet-name main --vnet-subnet-name services \ --storage-account-name ardemansstorageone --os-type linux --image-urn OpenLogic:CentOS:7.2:7.2.20160308 \ admin1
Esta máquina me la ha creado sin ip pública. Si queremos ip pública hay que añadir dos parámetros nuevos, como los que tiene la máquina que se crea a continuación:
$ azure vm create -v --json -g GroupOne -l "West Europe" -u "pmblanco" --ssh-publickey-file ~/.ssh/pmblanco.pub \
--nic-name admin2-1 --public-ip-name admin2 --public-ip-domain-name admin2 \
--vnet-name main --vnet-subnet-name services --storage-account-name ardemansstorageone \
--vm-size "Standard_A1" --os-type linux --image-urn OpenLogic:CentOS:7.2:7.2.20160308 \
admin2
Por lo que veo todo está etiquetado con un nombre, la IP privada, la IP pública y el interface de red, son cosas que se pueden re aprovechar después en otras máquinas. ¿? También se especifica la entrada de DNS que tendrá la IP pública en el DNS de Microsoft.
Seguramente hay formas más fáciles de lanzar esta creación de máquinas tan compleja, y parece que es mediante templates que definen los recursos que queremos crear de una sola vez. Algunas páginas de ejempos:
Tambien hay una cuenta en github con templates base:
He encontrado esta URL que parece que es un Visualizador de templates de azure que pinta el esquema de lo que monta un template
Uso de Templates
En el modo de ARM, en el que se definen todos los recursos que tiene una máquina, para facilitar las cosas han creado un sistema de templates, en el que mediante ficheros "json" podemos definir los recursos que queremos crear dentro de un grupo. De esta forma, lanzando un solo comando y especificando el template que queremos usar, podemos crear sistemas complejos.
Un ejemplo de como se lanzaría la creación de una máquina mediante un template:
$ azure group create -l westeurope eci-test
$ azure group deployment create \
-g eci-test \
-n eci-test-deployment-1 \
-f azuredeploy.json \
-e azuredeploy.parameters.json
En el fichero azuredeploy.json tendremos la definición de lo que queremos levantar y en azuredeploy.parameters.json los parámetros específicos para esta ejecución (se pueden pasar por línea de comandos)
Ejecución de código post-provisión
Existe una extensión de VM que ejecutar tareas una vez la máquina está provisionada. Podemos leer ejemplos: [2]
En la documentación pone que se puede elegir subir los scripts a un repo de blobs de Azure o a github. Habría que ver si es posible tambien desde otros repositorios de ficheros, en teoría no debería haber problemas.
El ejemplo subiendo el código a un repo de blobs de Azure
Después de crear el código que queremos ejecutar en la nueva VM que queremos crear tendremos que subirlo al contenedor de almacenamiento de azure. Podemos ver esto en la sección de almacenamiento.
{
"type": "Microsoft.Compute/virtualMachines/extensions",
"name": "[concat(variables('vmName'),'/newuserscript')]",
"apiVersion": "[variables('apiVersion')]",
"location": "[parameters('location')]",
"dependsOn": [
"[concat('Microsoft.Compute/virtualMachines/', variables('vmName'))]"
],
"properties": {
"publisher": "Microsoft.OSTCExtensions",
"type": "CustomScriptForLinux",
"typeHandlerVersion": "1.4",
"settings": {
"fileUris": [
"https://ardemanscommon.blob.core.windows.net/myblob/test.sh"
],
"commandToExecute": "bash test.sh"
},
"protectedSettings": {
"storageAccountName": "ardemanscommon",
"storageAccountKey": "<una_key_de_la_cuenta_de_almacenamiento>"
}
}
}
Este es un trozo de un template de azure que va dentro de la sección "resources", y además depende de una VM que habremos creado en el mismo template. A destacar, hay una sección settings y una sección protectedSettings. La diferencia está en lo sensibles que sean los datos que vamos a poner en ellos, y no se puede repetir un parámetro en ambas secciones.
Almacenamiento
Enlaces de interes
Creando una cuenta de almacenamiento
Se puede hacer con templates o por línea de comando, y por supuesto a través de la web.
Por línea de comando con el azure-cli:
$ azure storage account create -l westeurope -g group-common --type LRS ardemansstoragecommon
Esto crea una cuenta de almacenamiento que es la base con la que después se pueden crear diferentes tipos de contenedores. para ver la informacion de la cuenta de almacenamiento que acabamos de crear:
$ azure storage account show ardemansstoragecommon <..> data: Name: ardemansstoragecommon data: Url: /subscriptions/4e65d935-a8e7-40de-afce-f362f17dcf21/resourceGroups/group-common/providers/Microsoft.Storage/storageAccounts/ardemansstoragecommon data: Type: Standard_LRS data: Resource Group: group-common data: Location: westeurope data: Provisioning State: Succeeded data: Primary Location: westeurope data: Primary Status: available data: Secondary Location: data: Creation Time: data: Primary Endpoints: blob https://ardemansstoragecommon.blob.core.windows.net/ data: Primary Endpoints: queue https://ardemansstoragecommon.queue.core.windows.net/ data: Primary Endpoints: table https://ardemansstoragecommon.table.core.windows.net/ data: Primary Endpoints: file https://ardemansstoragecommon.file.core.windows.net/ info: storage account show command OK
Para poder trabajar con esta cuenta hará falta que tengamos una key. Podemos verla con el siguiente comando
$ azure storage account keys list ardemansstoragecommon -g group-common
Aparecen dos y podemos usar cualquiera de ellas (buscar si hay diferencias entre ellas)
Contenedores
Dentro una cuenta de almacenamiento podemos crear diferentes contenedores (no confundir con docker) de almacenamiento. Dentro de cada uno de estos contenedores podremos crear diferentes recursos de almacenmiento (como files o blobs) Para crear el contenedor nos hará falta la cuenta de almacenamiento que hemos creado antes con una Key
$ azure storage container create --container eci-tests-container -a ardemansstoragecommon -k <una_key>
Podremos ver la lista de contenedores creados con:
azure storage container list -a ardemansstoragecommon -k <una_key>
Recurso de blobs
Blob se le llama a cualquier tipo de objeto (ascii o binario). Una vez tenemos un contenedor podemos subir este tipo de objetos:
$ azure storage blob upload --container eci-tests-container -a ardemansstoragecommon -k <una_key> examples/centos-vm/blob/test.sh example/test.sh
El último de los parámetros es opcional, es el nombre del blob que vamos a subir, y si no especificamos nada sube con el mismo nombre que el fichero que estamos subiendo
Para acceder a estos ficheros que estamos subiendo como blob tendremos que componer la URL usando la de la cuenta de almacenamiento que hemos creado anteriormente. En nuestro ejemplo es: https://ardemansstoragecommon.blob.core.windows.net/, y tendremos que añadirle al path el contenedor que hemos creado, y el blob que hemos subido
$ curl https://ardemansstoragecommon.blob.core.windows.net/eci-tests-container/example/test.sh
Seguramente nos de un error porque el contenedor está creado como privado
Permisos del contenedor
El contenedor por defecto se crea como privado, pero tambien podemos crearlo como "publico". Esto se puede hacer a nivel de contenedor con el parámetro -p a la hora de crear el contenedor o después con el set:
azure storage container set --container eci-tests-container -a ardemansstoragecommon -k <una_key> -p Blob
Redes
IP's públicas
Para crear una IP pública en azure podemos usar el siguiente comando:
$ azure network public-ip create -g admin-vm -n ardemans-admin2 -l westeurope -a Dynamic
- -g --resource-group
- -n --name
- -l --location
- -a --allocation-method (dynamic,Static)
Desde Template
Un enlace de interés en el que viene las propiedades de este recurso para definir en un template: [3]
Para definir desde template como ejemplo podemos usar:
# Ejemplo copiado del enlace anterior
{
"name": "PIP01",
"location": "North US",
"tags": { "key": "value" },
"properties": {
"publicIPAllocationMethod": "Static",
"idleTimeoutInMinutes": 4,
"ipAddress": "104.42.233.77",
"dnsSettings": {
"domainNameLabel": "mylabel",
"fqdn": "mylabel.westus.cloudapp.azure.com",
"reverseFqdn": "contoso.com."
}
}
}
{
"apiVersion": "[variables('apiVersion')]",
"type": "Microsoft.Network/publicIPAddresses",
"name": "myPublicIP",
"location": "[variables('location')]",
"properties": {
"publicIPAllocationMethod": "[variables('publicIPAddressType')]",
"dnsSettings": {
"domainNameLabel": "[parameters('dnsLabelPrefix')]"
}
}
}
DNS
Listar registros de una zona
$ azure network dns record-set list -g group-common -z azure.ardemans.com
- -g --resource-group
- -z --dns-zone-name
Crear registros en una zona
Esto lo hacemos en dos partes, primero se crea el registro de DNS y después se le añaden datos al registro. Azure lo diferencia en que una entrada de registro en una zona de DNS es un record-set, y a este se le añaden registros.
En este ejemplo creamos el recordset web.azure.ardemans.com, que va a ser un cname, y después le añadimos el registro con el dato de a donde apunta este registro, "www.ardemans.com."
Creamos el record-set
$ zure network dns record-set create -g group-common -z azure.ardemans.com -name web -y CNAME -l 600
- -y --type
- -l --ttl
Después creamos el registro al que apunta este CNAME:
$ azure network dns record-set add-record -g group-common -z azure.ardemans.com -y CNAME -c www.ardemans.com. -n web
- -y --type
- -c --cname
- -n --name
Evidentemente, para crear este registro ha de existir antes el record-set
Con templates
Un ejemplo de como se crear una registro en una zona ya creada
{
"type": "Microsoft.Network/dnszones/a",
"name": "newZoneName/newRecordName",
"apiVersion": "2015-05-04-preview",
"location": "global",
"properties": {
"TTL": 3600,
"ARecords": [
{
"ipv4Address": "1.2.3.4"
},
{
"ipv4Address": "1.2.3.5"
}
]
},
"dependsOn": [
"[concat('Microsoft.Network/dnszones/', parameters('newZoneName'))]"
]
}
El dependsOn sobra si ya sabemos que la zona existe. En este caso los registros del record-set se definen ya en el propio recurso
