“Planeamos traer el corazón de la base de datos relacional a vista previa hoy, y estamos apuntando a un disponibilidad general para mediados de 2017”

Anunció Scott Guthrie, Vicepresidente Ejecutivo de la Unidad de Nube y Empresas de Microsoft. Fuente: Microsoft Blog.

 

Esto es una enorme decisión para Microsoft, y de esta forma está probando su compromiso de convertirse en un proveedor de soluciones horizontal a cualquier plataforma.

Este anuncio me tomó completamente por sorpresa; y, personalmente, estoy muy contento de ver el rumbo que está tomando Microsoft en el mundo de cross-platform.

Para recibir actualizaciones y novedades, o proveer feedback sobre SQL Server en Linux, los invito a que vean este sitio.

Esencialmente, hay tres maneras de reducir costos a través del cloud:

• Delegar la administración de IT en terceros.
• Optimización del uso de recursos.
• Economía de escala.

Delegar la administración de IT en terceros

Si tuviéramos que montar todo nuestro centro de datos, servidores, array de servidores o lo que fuera, eso trae consigo algunos temas a tener en cuenta. Por ejemplo:

• Comprar equipos (gastos upfront, o "comprar todo de una").
• Cableado
• Networking
• Refrigeración
• Comprar licencias (de ser necesario).
• Control de acceso/seguridad
• Cuidado del espacio físico
• Planes de contingencia
• Administración de sistema operativo/software/etc.
• Otros (que pueden ser muchos)

En cambio, si delegamos esta responsabilidad en un tercero, todo esto estará a cargo de ellos. Nosotros simplemente accedemos remotamente a un ambiente en donde tenemos control desde el Sistema Operativo (Infraestrucutra) para arriba (IaaS), o desde la Plataforma para arriba (PaaS), o desde la aplicación (Software) para arriba (SaaS). Por supuesto que nuestra administración no será "nula", pero definitivamente no tendremos que ocuparnos de todo lo mencionado arriba ni tampoco enfrentar costos upfront. 

Optimización del uso de recursos

Este apartado es fundamental, y es el principal motivo por el cual la nube es más económica; sin embargo, no todos lo tienen en claro.

Recordemos que la nube se puede utilizar de forma elástica, es decir, le pido tantos recursos como necesito. Si necesito 1 servidor, la nube podrá aprovisionarlo, si necesito 100, los aprovisionará, si necesito 1000, lo mismo. De igual manera funciona para otros servicios, por ejemplo, si necesito 1 MB o 100 TB de storage, mismo concepto.

Teniendo en cuenta lo anterior combinado con la caracterísitca de pago por uso, acá seguro empezás a ver las ventajas. Si aún no lo viste, pongamos un ejemplo práctico.

Caso de estudio

Supongamos que soy el dueño de un restaurant y tengo una aplicación web para recibir pedidos online. Seguramente, la curva de tráfico será como la siguiente:

Un pico al mediodía, un pico más grande a la noche (cuando la gente hace más pedidos), y luego más tranquilo el resto del día.

Teniendo este escenario, si tuvieramos que comprar, alquilar o reservar servidores, deberíamos tener al menos tantos servidores como el mayor de los picos. Opcionalmente (y recomendado!), dejaré un 10 o 15% de holgura por si ese pico creciera.

Esto pareciera funcionar bien, sin embargo acá aparecen dos problemas:

• ¿qué pasa si el mayor pico crece?
• ¿qué pasa con los recursos ociosos? (Por ejemplo, a las 5 pm, mis servidores estarán al 5% cuando "pagué" para tener la capacidad de las 9 pm).

Los dos problemas mencionados son críticos. En el primer caso, la nube y su aprovisionamiento elástico permitirá utilizar más servidores en caso que fuera necesario. Para el segundo caso, podemos inversamente apagar servidores y ahorrar dinero, evitando recursos ociosos.

De manera más gráfica, una aplicación en la nube bien configurada debería comportarse de esta forma:

Como se puede ver, la curva azul representa a los servidores mientras que la violeta la demanda real. Cuanto más se asemejen estas dos curvas, menos dinero estaremos pagando al final del período ya que usamos únicamente lo que necesitamos.

Ahora comparemos las dos curvas:

Si nosotros pagamos por uso únicamente, entonces los costos estarán representados por el área debajo de cada una de las curvas (azul y roja), osea la integral de cada función. Como se puede ver, en el caso de la nube, lo máximo que podemos llegar a pagar es igual a lo mínimo que costarán los servidores dedicados (asumiendo el mismo costo por hora, lo cual no es cierto, hablo de esto más adelante).

En el primer caso, los costos al final del día serán 5 servidores * 24 horas.

En el segundo caso, (1 servidor/hora) + (1 servidor/hora) + ... + (3 servidores/hora) + ... + (5 servidores/hora) + ... + (1 servidor/hora) = 2.5 (en promedio) servidores/hora.

Al final del mes, esto será mucho más económico.

Seguro te preguntarás, ok perfecto, y entonces tengo que estar constantemente prendiendo y apagando?

La respuesta corta es sí, pero tené en cuenta que podes automatizarlo o dejar que Azure lo haga por vos. Existen servicios como Azure Automation que permiten prender y apagar recursos en base a tu necesidad. Al mismo tiempo, para todo lo que es PaaS, podés utilizar las reglas del Network Load Balancer o balanceador de cargas de red para configurar políticas de auto-scale. Con estas reglas, las instancias pueden aprovisionarse y desaprovisionarse de forma automática (!). Para más info, visitá este link.

Un ejemplo podés verlo en este post, donde configuro el auto-scale en base a una cola de mensajeria.

Otro buen ejemplo, es la configuración de escala automática de Websites en base al porcentaje de CPU de las máquinas virtuales:

Si el % de CPU en promedio es mayor a 80%, se encenderán más instancias, pero no más de 5. Si el porcentaje de CPU en promedio es menor al 60%, se apagarán instancias, pero no menos de 1. Para configurar distintas políticas, como Data In, Data Out, RAM u otros, lo podés hacer desde https://portal.azure.com

Economía de escala

Por último y no menor, este tema es importante también. Es lo mismo comprar 1 kg de bananas que 2 toneladas de bananas? No, seguramente el precio por unidad será mucho menor. Esto es lo mismo. Al estar nosotros hosteando nuestras apps en data-centers de volúmenes monstruosos, los costos empiezan a decrementarse. Esto es conocido como economía de escala.

Espero que sirva. Para más info, te dejo estos links:

• AzureBoxes
• Auto-scale con queues
• Azure pricing calculator
• Azure free trial
• Azure gratis para subscriptores MSDN y para BizSparks
• Documentation center

• Azure Cloud Services. Esencialmente son máquinas virtuales sin estado, esto significa, que la información debería almacenarse en un lugar compartido por todas las instancias (ejemplos: SQL database, Redis cache, blob storage, queue storage, etc). Esta arquitectura permite escalar horizontalmente hasta el infinito, de forma rápida, olvidándonos por completo de la administración del hardware. Te recomiendo leer esto.
• Azure Worker Roles. Son uno de los componentes de los cloud services. Esencialmente máquinas virtuales que corren código .NET, PHP, Python, Node.js, Java o Ruby. A diferencia de los web roles, no tienen un web server pre-instalado.
• Azure Queues. Las famosas colas de mensajería, que permiten que distintos escritores pongan un mensaje y distintos lectores lo tomen. Se pueden acceder vía REST (al igual que prácticamente todos los servicios de Azure) y existen SDKs para los distintos lenguajes.

El ejemplo que usaremos hoy es el ya conocido Twitter Bot. Si no lo conoces, mira este post.

Arquitectura de mensajería asincrónica

¿Cómo hacemos para que, por ejemplo. una aplicación .NET "hable" con una aplicación Java? Existen varias formas, siendo tal vez las más comunes los web services. Como sabremos, estos servicios son sincrónicos (envío algo, espero una respuesta). El patrón que presentamos acá es asincrónico, es decir, no espero una respuesta luego de ejecutar alguna acción.

Para mensajería asincrónica, frecuentemente se utilizan las colas de mensajería (existen otras estructuras también, como por ejemplo topics). El funcionamiento es muy sencillo: una aplicación escribe un mensaje (cola.GuardarMensaje("hola!")) y otra aplicación los lee (var mensaje = cola.LeerMensaje()). Esto funciona con la modalidad FIFO, o First In First Out (el primero que guardo es el primero que se lee). Como la cola de la panadería.

Dicho esto, imaginémonos que pueden haber muchas aplicaciones escribiendo mensajes y muchas aplicaciones leyendo estos mensajes. Azure Queues resuelven todo el tema de sincronización de escritura y lectura de mensajes.

Twitter Bot Multi-tenant

En el Twitter Bot, lo que sucede es lo siguiente: hay un worker role constantemente haciendo follow y escribiendo mensajes en la cola. Ahora supongamos que deseamos hacer que nuestro twitter bot sea multi-tenant, es decir, que atienda múltiples cuentas de twitter. Seguramente habrán varios worker roles escribiendo mensajes, y luego tendremos otro worker role procesando y haciendo unfollow. Acá nos damos cuenta de un problema: la cola puede llegar a crecer tanto que no llegamos a procesar todos los mensajes.

Escalar según la cantidad de mensajes en una cola de mensajería

Azure provee una solución muy sencilla para esto, y es el auto-scale basado en la cantidad de mensajes en una cola. Esencialmente, es una manera de definir una política de escala.

Ahora podemos elegir qué worker escalamos:

Elegimos queue ó cola y definimos las políticas:

Las políticas son las siguientes:

• Instance Range o Rango de Instancias: estos son los umbrales de cantidades máximas y mínimas de workers que estás dispuesto a tener prendidos.
• Account or Namespace: la cuenta de storage de la cola.
• Queue Name: nombre de la cola de referencia.
• Target Per Machine: cantidad de mensajes por worker. Ejemplo, si Target = 2000 y hay 6000 mensajes, habrán 3 workers.
• Scale Up By: cantidad de workers a instanciar en simultáneo.
• Scale Up Wait Time: cuánto tiempo esperarmos para prender otra instancia.
• Scale Down By: cantidad de workers para desinstanciar en simultáneo.
• Scale Down Wait Time: cuánto tiempo esperamos para apagar otra instancia.

Listo. Ahora así funcionará mi arquitectura:

Hay n workers procesando tweets y escribiendo mensajes en la cola users. En base a la cantidad de mensajes, habrá entre 1 y 3 worker roles haciendo unfollow. Si hay 2000 o menos mensajes en la cola, habrá 1 solo. Si hay entre 2000 y 4000 mensajes en la cola, habrá 2 workers. Si hay 4000 o más mensajes, habrá 3 workers procesando mensajes.

No obstante, existen escenarios donde necesitamos conocer un poco más sobre la capa subyacente a mi aplicación. Por ejemplo, que pasa si necesitamos conocer la lista de locales instalados en el sistema operativo?

Con estos simples pasos, les muestro una manera de consultar vía PHP la lista de locales instalados.

El código que tenemos que ejecutar será el siguiente:

<?php
header( 'Content-Type: text/html; charset=utf-8' );
// source of the list:
// https://msdn.microsoft.com/en-us/library/39cwe7zf(v=vs.90).aspx
$langs = array(
    // language, sublanguage, codes
    array( 'Chinese', 'Chinese', array( 'chinese' ) ),
    array( 'Chinese', 'Chinese (simplified)', array( 'chinese-simplified', 'chs' ) ),
    array( 'Chinese', 'Chinese (traditional)', array( 'chinese-traditional', 'cht' ) ),
    array( 'Czech', 'Czech', array( 'csy', 'czech' ) ),
    array( 'Danish', 'Danish', array( 'dan', 'danish' ) ),
    array( 'Dutch', 'Dutch (default)', array( 'dutch', 'nld' ) ),
    array( 'Dutch', 'Dutch (Belgium)', array( 'belgian', 'dutch-belgian', 'nlb' ) ),
    array( 'English', 'English (default)', array( 'english' ) ),
    array( 'English', 'English (Australia)', array( 'australian', 'ena', 'english-aus' ) ),
    array( 'English', 'English (Canada)', array( 'canadian', 'enc', 'english-can' ) ),
    array( 'English', 'English (New Zealand)', array( 'english-nz', 'enz' ) ),
    array( 'English', 'English (United Kingdom)', array( 'eng', 'english-uk', 'uk' ) ),
    array( 'English', 'English (United States)', array( 'american', 'american english', 'american-english', 'english-american', 'english-us', 'english-usa', 'enu', 'us', 'usa' ) ),
    array( 'Finnish', 'Finnish', array( 'fin', 'finnish' ) ),
    array( 'French', 'French (default)', array( 'fra', 'french' ) ),
    array( 'French', 'French (Belgium)', array( 'frb', 'french-belgian' ) ),
    array( 'French', 'French (Canada)', array( 'frc', 'french-canadian' ) ),
    array( 'French', 'French (Switzerland)', array( 'french-swiss', 'frs' ) ),
    array( 'German', 'German (default)', array( 'deu', 'german' ) ),
    array( 'German', 'German (Austria)', array( 'dea', 'german-austrian' ) ),
    array( 'German', 'German (Switzerland)', array( 'des', 'german-swiss', 'swiss' ) ),
    array( 'Greek', 'Greek', array( 'ell', 'greek' ) ),
    array( 'Hungarian', 'Hungarian', array( 'hun', 'hungarian' ) ),
    array( 'Icelandic', 'Icelandic', array( 'icelandic', 'isl' ) ),
    array( 'Italian', 'Italian (default)', array( 'ita', 'italian' ) ),
    array( 'Italian', 'Italian (Switzerland)', array( 'italian-swiss', 'its' ) ),
    array( 'Japanese', 'Japanese', array( 'japanese', 'jpn' ) ),
    array( 'Korean', 'Korean', array( 'kor', 'korean' ) ),
    array( 'Norwegian', 'Norwegian (default)', array( 'norwegian' ) ),
    array( 'Norwegian', 'Norwegian (Bokmal)', array( 'nor', 'norwegian-bokmal' ) ),
    array( 'Norwegian', 'Norwegian (Nynorsk)', array( 'non', 'norwegian-nynorsk' ) ),
    array( 'Polish', 'Polish', array( 'plk', 'polish' ) ),
    array( 'Portuguese', 'Portuguese (default)', array( 'portuguese', 'ptg' ) ),
    array( 'Portuguese', 'Portuguese (Brazil)', array( 'portuguese-brazilian', 'ptb' ) ),
    array( 'Russian', 'Russian (default)', array( 'rus', 'russian' ) ),
    array( 'Slovak', 'Slovak', array( 'sky', 'slovak' ) ),
    array( 'Spanish', 'Spanish (default)', array( 'esp', 'spanish' ) ),
    array( 'Spanish', 'Spanish (Mexico)', array( 'esm', 'spanish-mexican' ) ),
    array( 'Spanish', 'Spanish (Modern)', array( 'esn', 'spanish-modern' ) ),
    array( 'Swedish', 'Swedish', array( 'sve', 'swedish' ) ),
    array( 'Turkish', 'Turkish', array( 'trk', 'turkish' ) )
);
echo '<table>'."\n";
echo '<tr>'."\n";
echo '  <th>Languange</th>'."\n";
echo '  <th>Sub-Languange</th>'."\n";
echo '  <th>Languange String</th>'."\n";
echo '</tr>'."\n";
foreach ( $langs as $lang ) {
    echo '<tr>'."\n";
    echo '  <td>'.$lang[0].'</td>'."\n";
    echo '  <td>'.$lang[1].'</td>'."\n";
    $a = array();
    foreach ( $lang[2] as $lang_code ) {
        $loc = setlocale( LC_ALL, $lang_code );
        $a []= $lang_code.' '.( false === $loc ? '✖' : '✔ - '.$loc );
    }
    echo '  <td>'.implode( '<br>', $a ).'</td>'."\n";
    echo '</tr>'."\n";
}
echo '</table>'."\n";
?>

Este script valida cuales son las locales instaladas, y en caso de estar instaladas, las imprime por pantalla.

Simplemente lo que hacemos es guardar este código en un archivo locale.php y lo subimos al web site. En mi caso, lo hice vía FTP. Luego finalmente ingreamos a nuestrositio.com/locale.php y veremos algo como lo siguiente:

A continuación el listado complete de locales soportadas por Azure Websites:

Chinese Chinese chinese ? - Chinese (Simplified)_China.936
Chinese Chinese (simplified) chinese-simplified ? - Chinese (Simplified)_China.936
chs ? - Chinese (Simplified)_China.936
Chinese Chinese (traditional) chinese-traditional ? - Chinese (Traditional)_Taiwan.950
cht ? - Chinese (Traditional)_Taiwan.950
Czech Czech csy ? - Czech_Czech Republic.1250
czech ? - Czech_Czech Republic.1250
Danish Danish dan ? - Danish_Denmark.1252
danish ? - Danish_Denmark.1252
Dutch Dutch (default) dutch ? - Dutch_Netherlands.1252
nld ? - Dutch_Netherlands.1252
Dutch Dutch (Belgium) belgian ? - Dutch_Belgium.1252
dutch-belgian ? - Dutch_Belgium.1252
nlb ? - Dutch_Belgium.1252
English English (default) english ? - English_United States.1252
English English (Australia) australian ? - English_Australia.1252
ena ? - English_Australia.1252
english-aus ? - English_Australia.1252
English English (Canada) canadian ? - English_Canada.1252
enc ? - English_Canada.1252
english-can ? - English_Canada.1252
English English (New Zealand) english-nz ? - English_New Zealand.1252
enz ? - English_New Zealand.1252
English English (United Kingdom) eng ? - English_United Kingdom.1252
english-uk ? - English_United Kingdom.1252
uk ? - English_United Kingdom.1252
English English (United States) american ? - English_United States.1252
american english ? - English_United States.1252
american-english ? - English_United States.1252
english-american ? - English_United States.1252
english-us ? - English_United States.1252
english-usa ? - English_United States.1252
enu ? - English_United States.1252
us ? - English_United States.1252
usa ? - English_United States.1252
Finnish Finnish fin ? - Finnish_Finland.1252
finnish ? - Finnish_Finland.1252
French French (default) fra ? - French_France.1252
french ? - French_France.1252
French French (Belgium) frb ? - French_Belgium.1252
french-belgian ? - French_Belgium.1252
French French (Canada) frc ? - French_Canada.1252
french-canadian ? - French_Canada.1252
French French (Switzerland) french-swiss ? - French_Switzerland.1252
frs ? - French_Switzerland.1252
German German (default) deu ? - German_Germany.1252
german ? - German_Germany.1252
German German (Austria) dea ? - German_Austria.1252
german-austrian ? - German_Austria.1252
German German (Switzerland) des ? - German_Switzerland.1252
german-swiss ? - German_Switzerland.1252
swiss ? - German_Switzerland.1252
Greek Greek ell ? - Greek_Greece.1253
greek ? - Greek_Greece.1253
Hungarian Hungarian hun ? - Hungarian_Hungary.1250
hungarian ? - Hungarian_Hungary.1250
Icelandic Icelandic icelandic ? - Icelandic_Iceland.1252
isl ? - Icelandic_Iceland.1252
Italian Italian (default) ita ? - Italian_Italy.1252
italian ? - Italian_Italy.1252
Italian Italian (Switzerland) italian-swiss ? - Italian_Switzerland.1252
its ? - Italian_Switzerland.1252
Japanese Japanese japanese ? - Japanese_Japan.932
jpn ? - Japanese_Japan.932
Korean Korean kor ? - Korean_Korea.949
korean ? - Korean_Korea.949
Norwegian Norwegian (default) norwegian ? - Norwegian (Bokm�l)_Norway.1252
Norwegian Norwegian (Bokmal) nor ? - Norwegian (Bokm�l)_Norway.1252
norwegian-bokmal ? - Norwegian (Bokm�l)_Norway.1252
Norwegian Norwegian (Nynorsk) non ? - Norwegian-Nynorsk_Norway.1252
norwegian-nynorsk ? - Norwegian-Nynorsk_Norway.1252
Polish Polish plk ? - Polish_Poland.1250
polish ? - Polish_Poland.1250
Portuguese Portuguese (default) portuguese ? - Portuguese_Brazil.1252
ptg ? - Portuguese_Portugal.1252
Portuguese Portuguese (Brazil) portuguese-brazilian ? - Portuguese_Brazil.1252
ptb ? - Portuguese_Brazil.1252
Russian Russian (default) rus ? - Russian_Russia.1251
russian ? - Russian_Russia.1251
Slovak Slovak sky ? - Slovak_Slovakia.1250
slovak ? - Slovak_Slovakia.1250
Spanish Spanish (default) esp ? - Spanish_Spain.1252
spanish ? - Spanish_Spain.1252
Spanish Spanish (Mexico) esm ? - Spanish_Mexico.1252
spanish-mexican ? - Spanish_Mexico.1252
Spanish Spanish (Modern) esn ? - Spanish_Spain.1252
spanish-modern ? - Spanish_Spain.1252
Swedish Swedish sve ? - Swedish_Sweden.1252
swedish ? - Swedish_Sweden.1252
Turkish Turkish trk ? - Turkish_Turkey.1254
turkish ? - Turkish_Turkey.1254

Si aun no tenés una cuenta en Microsoft Azure, te dejo algunas formas de empezar gratis:

• Free trial
• Subscriptores MSDN
• Miembros de BizSpark

Antes de montar tu servidor, vas a necesitar decidir tamaños de máquina y data center donde hostear tu aplicación. Para lo primero, te recomiendo este artículo. Para lo segundo, te recomiendo leas este otro.

Como es usual, arrancamos entrando al portal de Azure en https://manage.windowsazure.com y nos autenticamos con nuestra Microsoft account.

Damos click en Virtual Machines > Images > Browse VM Depot

Luego buscamos LAMP y la version del stack que deseamos. Yo en este caso elijo la última, 5.6.0.0 (Bitnami). Damos next.

Elijo Sur de Brasil por motivos de latencia. Finish.

Lo que estamos hacienda ahora es bajarnos la imagen virtual del ambiente a nuestra cuenta de almacenamiento. Lo que sigue es registrar esa imagen y luego crear un servidor a partir de esa imagen. Para ello seguimos estos pasos:

Ya está registrada. Ahora creamos el servidor hacienda click en New y luego los siguientes pasos:

Ahora vemos que aparece LAMP, elegimos y damos next.

Damos finish para comenzar la creación de la VM.

Listo, esta creada. Desde Dashboard podemos administrarla. Ahora me conectaré vía SSH para tener control del servidor, aunque podría eventualmente hacerlo vía RDP o algún otro protocolo soportado que vemos en la lista.

Ahora agregamos un endpoint.

Una vez que abrimos el endpoint, nos conectamos utilizando PuTTY utilizando los valores marcados en amarillo.

Usamos las mismas credenciales que especificamos al crear la máquina virtual.

Todo el stack (Apache, MySQL, PHP) está instalado en bitnami@demoLAMP:/home/bitnami/stack$. Adicionalmente, Bitname también nos trae instalado Git, Ruby, SQLite. Bastante cómodo.

¡Listo! En el próximo paso de estas series veremos manejo básico de Linux para aquellos que no lo conozcan. Para todos los demás, ya podemos empezar a jugar con nuestro ambiente LAMP.

Si aun no tenés una cuenta en Microsoft Azure, te dejo algunas formas de empezar gratis:

• Free trial
• Subscriptores MSDN
• Miembros de BizSpark

Derechos de autor

Esta guía fue 100% creada por Branko Straub, quien forma parte de nuestro equipo de Microsoft Student Partners en Argentina y Uruguay. Les recomiendo que pasen por su blog, ya que frecuentemente sube artículos super interesantes sobre Azure y desarrollo de aplicaciones móviles, entre otros tema.

Comentarios antes de empezar

Antes de montar tu servidor, vas a necesitar decidir tamaños de máquina y data center donde hostear tu aplicación. Para lo primero, te recomiendo este artículo. Para lo segundo, te recomiendo leas este otro.

Configuración en Azure

Lo primero que vamos a hacer es crear nuestra VM, en este tutorial vamos a optar por un Ubuntu 12.04 LTS (Long Term Support)

Completamos los datos requeridos para el loggin, nombre de la maquina, tamaño, etc.

Configuración en la VM

Una vez que se termino de crear la maquina virtual, en nuestra pc bajamos el PuTTY para conectarnos remotamente a la terminal de nuestra VM corriendo Ubuntu.
https://www.chiark.greenend.org.uk/~sgtatham/putty/download.html

Una vez que lo bajamos, lo abrimos y compleamos la ip con nuestra direccion de DNS que previamente elegimos:

Si hicimos todo bien nos saldrá una advertencia a la cual le damos “Yes” y proseguimos.

Ahora nos va pedir nuestro usuario y luego la clave, en mi caso “azureuser” y mi clave [Símbolo]

Una vez que nos conectamos exitosamente, vamos a introducir los siguientes comandos en este orden:
sudo apt-get update
sudo apt-get dist-upgrade
sudo apt-get install git-core

Si alguno de estos les pide confirmación ponen “Y” y luego enter.

Una vez que ejecutamos esos tres comandos que básicamente lo que hacen es actualizar el sistema y luego bajar el GIT Server, lo siguiente que hacemos es ejecutar los siguientes:
sudo –s
adduser git (les va a pedir datos del usuario completenlos)
su azureuser (nos volvemos a loggear como azureuser)

Una vez que hicimos eso, ahora proseguimos con los siguientes:
mkdir ~/repositories
sudo apt-get install acl
chmod 700 ~/repositories
sudo chown git:git ~/repositories

Ahora seguimos con estos:

getfacl ~/repositories
sudo ln -s /home/$USER/repositories /git
ls -al /git

Cuando ya terminamos con todos estos comandos el siguiente paso es bajar el PuTTY Key Generator que va servir para autentificar nuestra conexión a la VM y además para luego validar la conexión a nuestro repo de GIT.

https://www.chiark.greenend.org.uk/~sgtatham/putty/download.html

Lo abrimos, le damos generar:

Nos va a pedir que movamos el mouse para generar la clave de manera aleatoria:

Ingresamos una clave, y luego guardamos la clave privada:

La clave privada la guardamos en el escritorio y ahora copiamos la publica:

Volvemos a nuestra conexión a la terminal remota y ahora vamos a ejecutar lo siguiente

• sudo –s

• mkdir /home/git/.ssh

• echo "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAQEAp7c7YmVnqeHAtiDBmpoJ3TdlH0RzgXzVu89FNN5qbqgZtnHAmqmTWqtn2lrwcuZncAAdQZ7zjW6KI/7W3TYVu8WsFQbfm5puKq0jNGyPNs0IdukDmVnBNniHaC/cXwmgNbw12puuzFFKXlICIiZ9NDUWG9+3m8JkxaZc6jZajj6ZVZqA/K6HdXX3aUD38jmQmT7J5eleAskZa2H/st6gmBBI7kUranhJuvBBhiQaNQyRRD4CRGHrAEMzy1Zxh5d5Y/4nFHjxldS+tDmTG6Ki4g0MZwUCa8s7cH7ZGWgAlGNd+UcWUsRb4cU6GMLVTeHCwb81Odkof7rdkOAC7MQVGQ== rsa-key-20141018" >> /home/git/.ssh/authorized_keys

*Reemplazando lo que está en negrita por su propia clave pública.

Desconectamos nuestra sesión de PuTTY para ahora abrir una nueva, pero ahora vamos a opciones avanzadas, luego SSH y por ultimo Auth, ahora elegirmos Browse y seleccionamos la clave privada que previamente habíamos exportado:

Una vez que hicimos eso vamos a ver que ahora nos loggeamos como “git”, la clave que nos va a pedir es la que usamos cuando generamos la clave pública con el PuTTY Key Generator:

Por ultimo corremos los siguientes comandos:
cd /git
git init --bare myrepo.git

Configuración en tu PC

Instalamos los siguientes programas:
https://msysgit.github.io/

https://code.google.com/p/tortoisegit/wiki/Download?tm=2

Ej: una vez que instalamos TortoiseSVN hacemos click derecho en una carpeta y ponemos gitClone

Ponemos nuestro DNS de Azure y elegimos nuestra clave privada que previamente generamos:

A continuación nos va a pedir la clave que elegimos para dicha Key y por último el usuario: elegimos git

Gracias a todos y espero que les haya sido útil.
Cualquier duda, consulta o comentario será más que bienvenido.

Si aun no tenés una cuenta en Microsoft Azure, te dejo algunas formas de empezar gratis:

• Free trial
• Subscriptores MSDN
• Miembros de BizSpark 

Derechos de autor

Esta guía fue 100% creada por Branko Straub, quien forma parte de nuestro equipo de Microsoft Student Partners en Argentina y Uruguay. Les recomiendo que pasen por su blog, ya que frecuentemente sube artículos super interesantes sobre Azure y desarrollo de aplicaciones móviles, entre otros temas.

Comentarios antes de empezar

Antes de montar tu servidor, vas a necesitar decidir tamaños de máquina y data center donde hostear tu aplicación. Para lo primero, te recomiendo este artículo. Para lo segundo, te recomiendo leas este otro.

Archivos necesarios:

https://1drv.ms/1zdZMJK

Configuración en Azure

Lo primero que necesitamos hacer una vez que tenemos activa nuestra cuenta de Azure es agregar una tarjeta de crédito, si bien el servicio SendGrid es gratis hasta 25.000 emails por mes, al ser un complemento de la tienda de Azure este requisito es indispensable.
Prosigamos a agregar la tarjeta:
En el portal de Azure si vamos a la parte de adminstracion de Suscipciones veremos algo asi:
Hacemos click para cambiar la configuración.

Ahora vamos a ver lo siguiente agregamos un método de pago nuevo, en mi caso una tarjeta de crédito VISA.

Una vez que agregamos la  tarjeta y ponemos aceptar vamos a ver una opción que nos dice quitar el limite de gasto, esto no es necesario, tienen la opción de hacerlo. Pero una vez agregada la tarjeta alcanza con cerrar dicha ventana y regresar al portal.

Una vez que volvimos al portal ponemos “nuevo” y luego seleccionamos “Tienda”

Buscamos SendGrid y le damos Ok:

Nos da la opción de elegir un nombre y su ubicación geográfica:

Ya que es un servicio pago, veremos un resumen de la transacción, pero si eligimos correctamente la versión gratuita de 25.000 emails, veremos como el resumen total aparecerá en 0 pesos:

Una vez creado debemos anotar los datos de conexión y luego ir al portal de administración de SendGrid para configurar unos pequeños detalles:

Anotamos el usuario y la contraseña que nos serán útiles luego:

Nos dirigimos al portal de administración, en la parte inferior en Azure hay un ítem que nos permite ingresar al mismo directamente, veremos en la parte superior del portal de SendGrid que hay una advertencia, clickeamos ahí para completar los datos que faltan

Terminamos de configurar todo y veremos todos los “ticks” en verde:

Una vez realizados todos estos pasos ya hemos terminado con la configuración de todo lo que es “Cloud” ahora vamos a remitirnos al Visual Studio.

Configuración en Visual Studio

Para el resto del tutorial yo opte por realizar el programa en .Net (C#) pero cabe destacar que SendGrid permite JS, C#, y además cuenta con una WebApi entre otras cosas.
Recordemos que para continuar deben bajar el proyecto que se encuentra alojado en OneDrive: https://1drv.ms/1zdZMJK

Lo descomprimimos, lo iniciamos y lo único que debemos hacer es realizar unos pequeños cambios en el código:

Donde dice “var credentials = new NetworkCredential("usuario", "contraseña");”
Reemplazamos usuario y contraseña por las nuestras (las que anotamos antes).
Luego podemos adaptar el código a nuestro gusto y necesidades.

Observaciones:

myMessage.From = new MailAddress("atencion@heqsoa.onmicrosoft.com");
Esta opción nos permite elegir el remitente que va a ver el usuario que recibe el email.

List<String> recipients = new List<String>

            {

                @"Jeff Smith <Jeff@hotmail.com
                @"Anna Lidman <Anna@outlook.com>",

                @"Peter Saddow <Peter@microsoft.com>"

};

Esto nos permite agregar los usuarios que van a recibir los emails, en este caso agregue tres destinatarios a mano, pero los mismos se pueden cargar desde un archivo Txt, Excel, SQL, etc.
myMessage.Subject = "Azure Boxs Testing";
Acá podemos cambiar el asunto del email.

StreamReader reader = File.OpenText(@"C:\email.html");            
myMessage.Html = reader.ReadToEnd();
Ya que la mayoria de los emails hoy en dia se encuentran en format HTML podemos leer nuestro email desde un archivo de esta manera y luego cargarlo.
myMessage.AddAttachment(@"C:\file1.txt");

Esto nos deja enviar archivos adjuntos.

Una vez realizados todos los cambios que desean pueden probar enviar un email de prueba, en mi caso me base en un email de ImagineCup 2015, como pueden observar son libres de elegir el remitente que ustedes deseen ya que el encargado de enviar los emails es SendGrid y no su casilla de email:

Gracias a todos y espero que les haya sido útil.
Cualquier duda, consulta o comentario será más que bienvenido.

Si aun no tenés una cuenta en Microsoft Azure, te dejo algunas formas de empezar gratis:

• Free trial
• Subscriptores MSDN
• Miembros de BizSpark

Derechos de autor

Esta guía fue 100% creada por Branko Straub, quien forma parte de nuestro equipo de Microsoft Student Partners en Argentina y Uruguay. Les recomiendo que pasen por su blog, ya que frecuentemente sube artículos super interesantes sobre Azure y desarrollo de aplicaciones móviles, entre otros tema

Comentarios antes de empezar

Antes de montar tu servidor, vas a necesitar decidir tamaños de máquina y data center donde hostear tu aplicación. Para lo primero, te recomiendo este artículo. Para lo segundo, te recomiendo leas este otro.

Configuración en Azure

Una vez creada nuestra cuenta, nos autenticamos en https://manage.windowsazure.com y vamos a websites y elegimos Nuevo.

Elegimos Website y luego De la Galeria

A continuación vamos a ver que hay varios gestores de contenidos (CMS) disponibles, en esta ocasión voy a elegir Joomla!

Ahora pasamos a configurar nuestra página:

Dirección URL y Región serán los que modificaremos, poniendo en el primero la dirección de su elección y en el segundo les aconsejo (por cuestiones de latencia) que elijan el Data Center ubicado en el Sur de Brasil.

Seguimos configurando nuestro sitio:

Ahora continuamos con Load Data sample: esta opción le indica al website si será creado con los datos que viene por default (precargados).

WebsiteName: el nombre que le queremos dar a nuestro Website.

Ponemos una contraseña de administrador y por ultimo agregamos un email de contacto.

Por último en lo que respecta en la creación de nuestro server debemos configurar el nombre de nuestra base de datos, su ubicación (Sur de Brasil) y aceptar los T&C.

Luego de unos segundos, o minutos como máximo, ya podremos observar que nuestro sitio con Joomla! ha sido creado y ya se encuentra accesible.

Ahora con nuestro sitio ya creado tenemos varias formas de empezar a subir contenido, como ya les mencione antes, en esta ocasión voy a optar por utilizar WebMatrix para eso vamos a necesitar hacer lo siguiente.

Configuración del Sitio

Hacemos click en nuestro sitio (entramos en los detalles del mismo) y luego apretamos en WebMatrix:

Procedemos a instalar WebMatrix:

Una vez terminado automáticamente va a proceder a abrir nuestra pagina correspondiente, y nos va preguntar si queremos descargar una copia de la misma o trabajar online.

Vamos a seleccionar "Edit live site directly" para este demo, la otra opción lo que hace es permitirnos descargar el sitio completo y trabajar con el mismo en localhost.

Ahora vemos con ya en WebMatrix tenemos acceso a todo el repositorio del sitio web

Personalizando nuestro sitio

La gestión del contenido de la pagina ya corre por cada uno de ustedes, pero es bastante sencillo ya que cuentan con el panel de administración de Joomla.

Lo primero que hacemos es loggearnos con nuestro usuario: admin, *password*

Una vez que nos logueamos vamos a ver un panel (dashboard) asi:

Desde aquí podemos entre otras cosas: gestionar el contenido, subir extensiones, templates, crear usuarios, cambiar el idioma, etc.

Para cambiar el template / subir uno nuevo, primero lo descargamos (puede ser desde aqui por ejemplo: https://www.joomla24.com/) luego lo subimos mediante WebMatrix a "\templates\"mitemplate"

Luego vamos a TemplateManager y lo vamos a poder seleccionar.

Otra opción que tenemos disponible es cambiar el idioma, en mi caso opte por cambiarlo a español:

Acá ya podemos observar como se ha cambiado el idioma exitosamente:

Luego de utilizar Joomla un rato, modificar templates, opciones, crear usuarios y demás. Podemos ver algo así:

Y no nos olvidemos, como todo esto esta corriendo en Microsoft Azure, podemos observar métricas, escalar, hacer backups y mucho más.

• Free trial
• Subscriptores MSDN
• Miembros de BizSpark

Derechos de autor

Esta guía fue 100% creada por Branko Straub, quien forma parte de nuestro equipo de Microsoft Student Partners en Argentina y Uruguay. Les recomiendo que pasen por su blog, ya que frecuentemente sube artículos super interesantes sobre Azure y desarrollo de aplicaciones móviles, entre otros temas.

Comentarios antes de empezar

Antes de montar tu servidor, vas a necesitar decidir tamaños de máquina virtual y data center donde hostear tu aplicación. Para lo primero, te recomiendo este artículo. Para lo segundo, te recomiendo leas este otro.

Configuración desde Azure

Para empezar, con nuestras cuentas activas de Azure nos dirigimos a https://manage.windowsazure.com/ para crear nuestro servidor. Una vez logueados deberían ver un portal de inicio similar al siguiente.

Hacemos click en “Nuevo” y deberíamos ver la siguiente pantalla, elegimos crear una Máquina Virtual y luego De la galería.

Para crear el servidor de Minecraft vamos a optar por crear un Windows Server 2008 RS SP1, lo seleccionamos y le damos siguiente.

Ahora nos remitimos a las configuraciones del servidor.

• Nombre: Nombre como queremos llamar al servidor, en este caso Minecraft.
• Capa: Elegimos Standard.
• Tamaño: Varia según la cantidad de procesos que queremos alojar en el servidor y la cantidad de jugadores a conectarse, pero con un servidor categoría A1 es suficiente.
• Usuario: este nombre luego será solicitado para conectarse al servidor.
• Contraseña: al igual que el usuario será solicitado luego.

*Nota: la contraseña debe contar con al menos, una letra mayúscula, un número y un carácter especial, EJ: “Minecraf1!”.

Ahora, tenemos que seguir configurando otros aspectos del servidor:

• Nombre DNS: este nombre será la dirección a la que se conecten las personas que quieran jugar, procuren usar un nombre genérico y fácil de acceder.
• Región: es el lugar donde se aprovisionara nuestro servidor, cuanto más cercano a los jugadores mejor, ya que esto implica menor latencia (ping).

El resto de las configuraciones dejar por defecto.

Por último tenemos que abrir un puerto en nuestro servidor, para que nuestro servidor de Minecraft pueda ser accesible. En este caso el puerto a abrir usa el protocolo TCP y es el numero 25565 como se puede ver a continuación.

La siguiente pantalla es un resumen de nuestro servidor y nos pregunta si queremos activar características especiales, no tocamos nada y lo dejamos como esta.

En esta pestaña veremos listadas todas nuestra máquinas virtuales, si hicimos todo bien dirá “creando la máquina virtual”, tras lo cual, un par de minutos después ya estará lista para usar.

Una vez que se crea hacemos click en la maquina virtual y vamos a la siguiente pagina “Extremos”

Seccionamos el puerto creado y ponemos editar.

Ahora el puerto privado debería ser “25565”, mientras que el público debería ser uno distinto a este por defecto. Lo que vamos a hacer es procurar que los dos sean iguales. Por ende cambiamos el público a 25565 y aceptamos.

Va a demorar unos segundos, una vez finalizado podemos continuar con el siguiente paso.

Una vez que se creó correctamente y cambiamos el puerto está lista para conectarse, volvemos al inicio y veremos algo así, clickeamos en conectar y nos bajara un archivo para conectarnos remotamente al servidor que acabamos de crear.

Lo abrimos y veremos el asistente de Windows para conexiones remotas:

Le damos “connect” o conectar, según corresponda. Ahora nos solicitara las credenciales, ósea, el usuario y clave antes elegidos. Elegimos “use another account” y procedemos a introducir los datos.

*Nos va a aparecer una advertencia de seguridad, a la que le damos “Yes” o Si.

Configuración desde el servidor

Nos aparecerá una pantalla con la que podemos interactuar con la máquina virtual.

Una vez en el navegador procedemos a descargar el servidor de Minecraft, pueden acceder directamente desde este link: https://minecraft.net/download.

Una vez que termina de bajar lo copiamos, por comodidad, dentro de una carpeta en el escritorio que llame “Minecraft”.

Lo ejecutamos y veremos un error como el siguiente.

El servidor de Minecraft requiere el Runtime de Java para poder funcionar, abrimos el navegador, o en su defecto se abrirá solo en la página de descarga. Y procedemos a bajarlo. Lo instalamos y ahora procedemos a configurar una variable de entorno para que funcione correctamente, para hacer eso, hay que seguir los siguientes pasos.

Abrimos el panel de control.

Hacemos click en “System”, “Advanced System Settings” y luego “Enviroment variables”

“New” y luego completamos los siguientes datos:
Name: JAVA_HOME
Value: C:\Program Files (x86)\Java\jre7

Damos OK, repetimos lo mismo en la otra ventana y cerramos todo (habiendo aceptado).

Volvemos a abrir el server de Minecraft.

Se va a abrir y luego a cerrar, creando los siguientes archivos.

Entramos al archivo llamado “eula” y cambiamos el valor de la ultima línea, donde dice “FALSE” por “TRUE”. Guardamos y cerramos el archivo.

Volvemos a abrir el server Minecraft, veremos algo asi.

Cerramos el servidor y veremos que ahora se crearon más archivos.

Vamos a modificar el archivo “server.properties” que se encuentra en dicha carpeta. Seleccionamos la segunda opción y ponemos “Ok”.

Ahora nos aparecerá esta otra ventana:

Seleccionamos “Notepad” y luego “Ok”.

Veremos el siguiente archivo de texto:

En la opción “online-mode = true” cambiamos el “true” por un “false” y en “server-ip = “ completamos con la ip que veremos en la parte superior derecha de la pantalla remarcada como “Internal Ip”, hacemos esos dos cambios y cerramos el archivo (guardando). Las demás opciones son las configuraciones del servidor. Siéntanse libres de explorar cada una de ellas.
*Nota: si apagamos y volvemos a encender nuestra maquina virtual (servidor) la ip interna puede verse alterada por lo que habrá que repetir este ultimo paso, actualizando en el archivo de configuraciones la misma.

A jugar!

Verificar efectivamente que nuestro servidor esta funcionando. Abrimos un cliente de Minecraft (en nuestra pc) o la de un conocido.

Vamos a Multiplayer, “add server” y ahí colocamos ponemos la dirección pública del servidor o lo que es mas fácil su dominio. El cual es el que eligieron antes, en mi caso es:

minecraftprueba.cloudapp.net

Si hicimos todo bien veremos algo así:

Nos conectamos al servidor y veremos como van apareciendo los jugadores.

Gracias a todos y espero que les haya sido útil.
Cualquier duda, consulta o comentario será más que bienvenido.

Con estos simples pasos, hacés que cada uno de tus miembros tenga los beneficios:

Ir a la página de BizSpark en: https://www.microsoft.com/startups

Una vez logueado con tu Microsoft account, vamos a My BizSpark, Manage

Acá agregas a los miembros de tu equipo:

Importante

Podes agregar 4 más, osea 5 en total. Cuidado con agregar miembros por equivocación ya que después queda ese slot asignado para siempre (de no ser así, con altas y bajas cualquier persona podría acceder a las licencias infinitamente). También con el link provisto podes pedir una excepción y agregar más miembros en caso de ser necesario.

Activar Azure para cada subscripción

Uno de los principales beneficios de BizSpark es el crédito disponible en Azure. Por cada cuenta, tenés disponibles U$S 150 dólares, entonces disponés de un máximo de 5 * U$S 150 = U$S 750 por mes, todos los meses durante los 3 años. El único tema con esto es que no podés acumular todo el crédito en una única subscripción, sino que son 5 individuales. De todas formas, los servicios de Azure son lo suficientemente independientes como para aprovechar estos beneficios: podes tener máquinas virtuales corriendo en distintas subscripciones, o cómputo en una y storage en la otra, otra subscripción para servicios móviles, etc.. Las combinaciones son inmensas y además gracias a Traffic Manager (balanceador de cargas) podés inclusive poner distintas subscripciones detrás de un único endpoint/dominio.

Para activar Azure para cada miembro, seguí estos pasos.

Si se te ocurre algún otro escenario cross-subcripción, déjalo en los comentarios!