Nuevo Balanceador de Carga a nivel de Aplicación en AWS

En la primavera de 2009 AWS pone en marcha el servicio Elastic Load Balancing (ELB) de AWS en la primavera de 2009 (puede ver en este enlace el anuncio de aquel momento). Elastic Load Balancing se ha convertido en un componente clave de la arquitectura para muchas aplicaciones que funcionan con AWS. En paralelo con Auto Scaling , Elastic Load Balancing simplifica en gran medida la tarea de la creación de aplicaciones y permite escalar hacia arriba y abajo mientras se mantiene una alta disponibilidad.

En el nivel
En el conocido modelo de red OSI, los equilibradores de carga se ejecutan habitualmente en la capa 4 (transporte) o en la capa 7 (aplicación).

Un equilibrador de carga de capa 4 funciona en el nivel de protocolo de red y no conoce el contenido de los paquetes de red, desconoce las características específicas de HTTP y HTTPS. En otras palabras, se equilibra la carga sin necesidad de saber mucho sobre ella.

Un equilibrador de carga de la capa 7 es más sofisticado y más potente. Se inspeccionan los paquetes, tiene acceso a las cabeceras HTTP y HTTPS, y (con más información) puede hacer un trabajo más inteligente de repartir la carga.

Equilibrado de carga a nivel de Aplicación de AWS

Este nuevo equilibrador de carga se ejecuta en la capa 7 y es compatible con una serie de características avanzadas. La opción inicial (que ahora se llama “balanceador de carga clásico”) está todavía disponible y continúa ofreciendo balanceado en las capas 4 y 7.

Los balanceadores de carga a nivel de aplicación, soportan aplicaciones que se ejecutan en contenedores. Soportan dos protocolos standar en la industria (WebSocket y HTTP/2) y además proporcionan visibilidad adicional sobre las intancias y contenedores destino. Sitios Web y aplicaciones móviles, que se ejecutan en contenedores o instancias EC2, pueden beneficiarse del uso de Balanceadores de carga a nivel de Aplicación.

A continuación vamos a ver más en detalle cada una de estas características y después crearemos un nuevo Balanceador de carga a nivel de aplicación.

Enrutado basado en contenido

Un balanceador de carga a nivel de aplicación tiene acceso a las cabeceras HTTP y permite enrutar peticiones a diferentes servicios adecuadamente. Por ejemplo, podemos querer enviar peticiones que incluyan “/api” en el path del URL a un grupo de servidores (que llamaremos grupo destino) y aquellas peticiones que contengan “/mobile” a otros. Enrutar peticiones de esta manera permite construir aplicaciones que se componen de múltiples microservicios que pueden ejecutarse y escalarse de forma independiente.

Como veremos, cada Balanceador de Carga a nivel de Aplicación permite definir hasta 10 reglas basadas en URL para enrutar peticiones a un grupo de servidores objetivo. Más adelante, AWS prevee dar acceso a otros métodos de enrutado.

Soporte para aplicaciones basadas en contenedores

Muchos usuarios de AWS están empaquetando sus microservicios en contenedores y alojandolos en Amazon EC2 Container Service. Esto permite a una única instancia de EC2 ejecutar uno o más servicios, pero puede presentar algunos desafíos interesantes para los balanceadores de carga tradicionales respecto al mapeo de puertos y a la comprobación de estado de funcionamiento.

El balanceador de carga a nivel de Aplicación conoce y soporta las aplicaciones basadas en contenedores. Esto permite a una instancia alojar diferentes contenedores que escuchan on diferentes puertos detrá del mismo grupo destino y además una comprobación más fina de la comprobación del correcto funcionamiento de los puertos.


Mejores métricas

En los balanceadores de carga de nivel de aplicación es posible obtener métricas de cada uno de los micro-servicios. Esta es una de las consecuencias de poder ejecutar cada uno de los micro-servicios en su propio grupo de servidores. Este incremento de visibilidad permite un mejor trabajo de escalado y reducción en respuesta a servicios individuales.

Los balanceadores de carga a nivel de aplicación proporcionan nuevos métricas CloudWatch incluyendo tráfico general (GB), número de conexiones activas, y la tasa de conexión por hora.


Soporte para protocolos adicionales y cargas de trabajo

El balanceador de carga a nivel de aplicación soporta dos protocolos adicionales: WebSocket y HTTP/2
WebSocket permite crear conexiones de largos periodos de espera entre el cliente y el servidor. Esta es una alternativa más eficiente al método de la “vieja escuela” que usaba conexiones HTTP que permanecían abiertas por largos periodos de tiempo. Los WebSocket son adecuados para dispositivos móbiles y pueden ser utilizados para enviar información dinámica minimizando el consumo de energía. Los ALB (Balanceadores de Carga a nivel de Aplicación) proporcionan soporte nativo para WebSocket a través de los protocolos ws:// y wss://.

HTTP/2 supone una mejora significativa del original HTTP 1.1. El nuevo protocolo soporta peticiones multiplexadas a través de una única conexió lo que reduce considerablemente el tráfico de red.


Creando un balanceador de carga a nivel de aplicación

Vamos a crear un ALB y a configurarlo para procesar tráfico.

La consola de Elastic Load Balancing permite crear dos tipos de balanceadores

alb_con_splash_1

alb_config_top_1

alb_config_butt_1

alb_pick_cert_1

alb_set_sec_group_1

elb_set_target_1

alb_register_targets_1

alb_review_1

alb_my_alb_active_1

alb_create_target_1

alb_add_rule_1

Referencias

1. New – AWS Application Load Balancer

2. Multiplexing: TCP vs HTTP2

3. New Features for Amazon EC2: Elastic Load Balancing, Auto Scaling, and Amazon CloudWatch

Como montar un servidor web en nuestro PC para realizar pruebas de estrés

Si estamos pensando en sacar algún tipo de aplicación web, puede ser interesante saber que estabilidad tendrá esta y cuantas visitas concurrentes soportará.

Por ello, en esta entrada se especificarán los pasos para realizar pruebas de estrés, desde nuestra propia máquina (usando el S.O. Centos y una máquina virtual), también se podría realizar dichas pruebas en maquinas de Amazon o en un servidor cualquiera.

 

PASO 1. Instalación de Centos en una Máquina Virtual sobre Windows. Esta máquina se utilizará como servidor php.

Necesitaremos descargar la versión de Virtual Box compatible con Windows e instalarla, la podremos descargar desde aquí en su web oficial. Luego necesitaremos descargar la imagen .iso del S.O. mencionado, lo cual podremos hacerlo desde también desde su web oficial. En nuestro caso la versión que hemos usado para realizar este tutorial es una versión minimal 6.6 (Descargar v6.6 minimal)
PASO 2. Configuración de Virtual Box.

    1. Hacer click en Nueva. Poner el nombre que queramos, tipo “Linux” y versión “Red Hat (32 bit)”. Hacer click en Siguiente.
    2. Establecer una memoria ram de 1024 MB y hacer click en Siguiente.
    3. Elegimos “Crear disco duro virtual ahora”. Click en Crear.
    4. Elegimos el tipo de disco “VDI (VirtualBox Dick Image) y hacemos click en Siguiente.
    5. Elegimos la opción de reservado dinámicamente. Click en Siguiente.
    6. Ahora hacemos click en Crear.
    7. Una vez creado, seleccionamos la máquina que acabamos de crear y hacemos click en “Configuración”.
    8. Ahora vamos a Almacenamiento → Controlador IDE → Controlador IDE/Vacio → (Icono de disco con flecha hacia abajo) → Seleccionar un archivo de disco virtual de CD/DVD… → (Buscar nuestra imagen .iso y seleccionar).
    9. Ahora configuramos la red: Ir a Red → Adaptador 1 → Conectado a:→ (Seleccionar Adaptador Puente y seleccionar la tarjeta de red de nuestro ordenador con la que nos conectamos a internet).
    10. Por último, hacemos click en Aceptar.

PASO 3. Configuración de Centos.

  1. Seleccionamos la máquina creada y hacemos click en Iniciar.
  2. Dejamos seleccionado “Install or upgrade an existing system”, pulsar Intro y esperar que cargue.
  3. Movemos con las flechas del teclado hasta seleccionar “SKIP” y pulsar Intro (esperar).
  4. Hacemos click en Next.
  5. Seleccionamos idioma (Spanish) y pulsamos en Next.
  6. Dejamos selecciono “Dispositivos de almacenamiento básicos” y hacemos click en “Siguiente”.
  7. Hacemos click en “Si, descarte todos los datos”
  8. Establecemos el nombre del equipo.
  9. Dejamos seleccionado “Europa/Madrid” y pulsamos en “Siguiente”.
  10. Establecemos la contraseña para el usuario root.
  11. Seleccionar “Remplazar sistema(s) Linux existente(s)” y pulsar “Siguiente”
  12. Hacemos click en “Escribir cambios al disco” y esperamos a que finalice la instalación
  13. Por último, reiniciamos.

PASO 4. Primer arranque y actualización.

  1. Usamos nuestro login y nuestra password para acceder como root.
  2. Ejecutamos el comando “ifconfig -a”. Se observa que la interfaz eth0 no tiene configuración IP y que no está levantada.
  3. Ejecutamos el comando “ifup et0″
  4. Ejecutamos “yum update”. Y pulsamos la tecla “s” para continuar cuando sea necesario.
  5. Ejecutamos “yum install nano”
  6. Ejecutamos “nano /etc/sysconfig/network-scripts/ifcfg-eth0″. Una vez dentro de este archivo cambiamos la linea “ONBOOT=no” por “ONBOOT=yes”. Guardamos y salimos. Con este paso habremos conseguido que la interfaz eth0 se levante automáticamente cada vez que arranquemos Centos.

PASO 5. Configuración de carpeta compartida entre Windows y Centos.

  1. Máquina → Configuración → Carpetas Compartidas
  2. Pulsamos sobre “Añadir Carpeta”
  3. Hacemos click en Ruta Carpeta → Otro → (Crear Carpeta en Escritorio y seleccionar) → Aceptar
  4. Seleccionamos “Automontar” y “Hacer Permanente”. Luego hacemos click en aceptar.
  5. Dentro de la máquina Centos, ejecutamos el comando “mkdir CarpetaCompartida”.
  6. Ejecutamos el comando “yum groupinstall “Development Tools” “
  7. Ejecutamos comando “yum install kernel-devel”
  8. Luego vamos a Dispositivos → Insertar la imagen de CD de las “Guest Additions”
  9. Ejecutamos el comando “mkdir /mnt/cd”
  10. Ejecutamos el comando “mount /dev/sr0 /mnt/cd”
  11. Ejecutamos el comando “cd /mnt/cd”
  12. Ejecutamos el comando “./VBoxLinuxAdditions.run”
  13. Ejecutamos el comando “mount –t vboxsf CarpetaCentos /root/CarpetaCompartida/”

Desde este momento, cualquier archivo que incluyamos en la carpeta creada en Windows, también aparecerá en la creada en Centos, y viceversa.

 

PASO 6. Instalación servidor Apache y mysql

  1. Ejecutamos el comando “yum install httpd”
  2. Ejecutamos el comando “nano /etc/sysconfig/iptables”
  3. Modificamos el fichero añadiendo bajo la línea “-A INPUT -m state –state NEW -m tcp -p tcp –dport 22 -j ACCEPT” la siguiente línea: “-A INPUT -m state –state NEW -m tcp -p tcp –dport 80 -j ACCEPT”
  4. Ejecutamos el comando “service iptables start”
  5. Ejecutamos el comando “service httpd start”
  6. Ejecutamos el comando “yum install mysql-server”
  7. Ejecutamos el comando “service mysqld start”
  8. Ejecutamos los comandos “chkconfig httpd on” y “chkconfig mysqld on”
  9. Configuramos mysql-server ejecutando “/usr/bin/mysql_secure_installation”, estableciendo una contraseña y respondiendo si a todo.
  10. Ejecutamos el comando “yum install php php-mysql”
  11. Ejecutamos el comando “service httpd restart”

Instalacion Servidores

PASO 7. Probando php

  1. Ejecutamos el comando “nano /var/www/html/info.php” y escribirmos lo siguiente: <?phpphpinfo();?>
  2. Ejecutamos el comando “ifconfig” y apuntamos la dirección ip de la interfaz eth0
  3. Abrimos un navegador en Windows y escribimos: [IP_ETH0]/info.php

PASO 8. Descargar la BD, crearla e importarla

  1.  Descargar en Windows la BD en formato .csv (“IP2LOCATION-LIST-DB5.CSV”) desde la siguiente url: Descargar BD
  2. Copiar la BD a la carpeta compartida creada anteriormente.
  3. En Centos, ejecutamos el comando “cd /root/CarpetaCompartida”
  4. Ejecutamos el comando “mysql –u root –p”, introducimos nuestra contraseña y a continuación los siguiente comandos:CREATE DATABASE ip2location;USE ip2location;CREATE TABLE `ip2location_db5`(`ip_from` INT(10) UNSIGNED,`ip_to` INT(10) UNSIGNED,`country_code` CHAR(2),`country_name` VARCHAR(64),`region_name` VARCHAR(128),`city_name` VARCHAR(128),`latitude` DOUBLE,`longitude` DOUBLE,INDEX `idx_ip_from` (`ip_from`),

    INDEX `idx_ip_to` (`ip_to`),

    INDEX `idx_ip_from_to` (`ip_from`, `ip_to`)

    ) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

    LOAD DATA LOCAL

    INFILE ‘/root/CarpetaCompatida/IP2LOCATION-LITE-DB5.CSV’

    INTO TABLE

    `ip2location_db5`

    FIELDS TERMINATED BY ‘,’

    ENCLOSED BY ‘”‘

    LINES TERMINATED BY ‘\r\n’

    IGNORE 0 LINES;

  5. Ejecutamos el comando “exit”

Descargar, Crear, Importar BD 1

PASO 9. Creación del fichero .php que acceda a la BD y devuelva una respuesta

  1. Ejecutamos el comando “mkdir /var/www/html/MAC”
  2. Ejecutamos el comando “nano /var/www/html/MAC/localizarIpv2.php” y escribimos lo siguiente:<!DOCTYPE html><html ><head><meta charset=”utf-8″><meta http-equiv=”X-UA-Compatible” content=”IE=edge”><meta name=”viewport” content=”width=device-width, initial-scale=1″><meta name=”description” content=”"><meta name=”author” content=”"><title>Localiza tu IP</title></head><body><div>

    <div>

    <h2>Localizador IP</h2>

    <?php

    function Dot2LongIP ($IPaddr)

    {

    if ($IPaddr == “”) {

    return 0;

    } else {

    $ips = split (“\.”, “$IPaddr”);

    return ($ips[3] + $ips[2] * 256 + $ips[1] * 256 * 256 + $ips[0] * 256 * 256 * 256);

    }

    }

    if(isset($_GET["ip"]) & !empty($_GET["ip"])){

    $result=Dot2LongIP($_GET["ip"]);

    $host = “localhost”;

    $user = “root”;

    $pass = “localhost”;

    $db = “ip2location”;

    $conexion = mysql_connect($host, $user, $pass);

    mysql_select_db($db, $conexion);

    $str=”SELECT IP.country_name, IP.region_name, IP.city_name, IP.latitude, IP.longitude FROM ip2location_db5 IP

    WHERE (IP.ip_from <= “.$result.”) AND (IP.ip_to >= “.$result.”)”;

    $query = mysql_query($str);

    $row=mysql_fetch_array($query);

    echo(“<h3>Pais:”.$row[0].”</h3>”);

    echo(“<h3>Region:”.$row[1].”</h3>”);

    echo(“<h3>Ciudad:”.$row[2].”</h3>”);

    }

    else{

    echo(“<h3>Parámetros no validos</h3>”);

    }

    ?>

    </div>

    </div>

    </body>

    </html>

  3. Probamos en un navegador en Windows la siguiente dirección: “http://[direccion ip eth0]/MAC/localizarIpv2.php?ip=125.12.36.158″

PASO 10. Crear una nueva máquina virtual repitiendo los pasos 1, 2, 3 y 4. Se puede realizar en el mismo ordenador o en otro conectado a la misma red.

En la nueva máquina virtual…

  1. Ejecutamos el comando “yum install wget”
  2. Ejecutamos el comando “wget http://download.joedog.org/siege/siege-3.0.9.tar.gz
  3. Ejecutamos el comando “tar xvfz siege-3.0.9.tar.gz”
  4. Ejecutamos el comando “cd siege-3.0.9″
  5. Ejecutamos el comando “./configure”
  6. Ejecutamos el comando “make”
  7. Ejecutamos el comando “make install”

Pruebas estres siege 0

PASO 11. Pruebas de estrés (desde la máquina cliente).

Primera prueba ejecutando el comando “siege –t 1m –c 100 –u http://[ip maquina servidor]/MAC/localizarIpv2.php?ip=125.12.36.158″

Los resultados son los siguientes:

Transactions:                   3066 hits

Availability:                 100.00 %

Elapsed time:                  62.96 secs

Data transferred:               1.70 MB

Response time:                  4.18 secs

Transaction rate:              48.70 trans/sec

Throughput:                     0.03 MB/sec

Concurrency:                  203.41

Successful transactions:        3066

Failed transactions:               0

Longest transaction:           34.83

Shortest transaction:           0.30

 

Una primera forma de mejorar estos resultados es modificar la consulta con el comando “nano /var/www/html/MAC/localizarIpv2.php” modificando la línea:

WHERE (IP.ip_from <= “.$result.”) AND (IP.ip_to >= “.$result.”)”;  por la línea:

WHERE (IP.ip_to >= “.$result.”) LIMIT 1″;

 

Otro forma en la que pueden mejorarse estos resultados es modificando la configuración del servidor Apache para que lance más hilos concurrentes. Esto se hace ejecutando el comando “nano /etc/httpd/conf/httpd.conf” y modificando en el fichero las líneas:

StartServers -> 15

MinSpareServers -> 15

MaxSpareServers -> 35

Configuracion httpd 0

Tras esto, antes de realizar la siguiente prueba de estrés deberemos ejecutar el comando “service httpd restart”

Importar una imagen de VM en una instancia AWS

En primer lugar necesitamos una máquina virtual la cual vamos a cargar en Amazon (El equipo desde el que se trabaja en este caso es Windows, en caso de emplear un sistema basado en Unix consultar la configuración de CLI en Linux o Mac). En este caso se trata de una máquina CentOS con phpmyadmin instalado a través de apache con datos integrados.

CapturaPara ello necesitamos el o los discos que estén montados en esta imagen (formato vhd) y los colocamos en un directorio bien localizado el cual tendremos que acceder más tarde mediante consola. Una vez se tenga preparada la “imagen” se procede a la ejecución de los pasos para importarla a AWS:

  1. Instalar el CLI de Amazon EC2 en tu equipo. Comenzamos descargando el archivo comprimido desde la web de Amazon (es necesario tener instalado Java 1.7 mínimo). Para que estos comandos resulten efectivos debemos crear una serie de variables de entorno que permitan el manejo de dichos comandos de forma cómoda por la ventana de comandos del sistema.
    • Click en Inicio, Equipo, Propiedades.
    • Configuración avanzada del sistema.
    • Variables de entorno.
    • Variables de usuario, click en Nueva.
    • Nombre de variable, JAVA_HOME.
    • Valor de la variable, el path del ejecutable de Java: “C:\Program Files (x86)\Java\jre7” (sin incluir el directorio bin).
    • Ok.

    Estos mismos pasos hay que repetirlos para crear el resto de variables necesarias:

    • Nombre de variable EC2_HOME, valor de la variable path del directorio de CLI descargado: “C:\AWS\EC2\ec2-api-tools-1.7.0.0“.
    • Nombre de la variable AWS_ACCESS_KEY, valor de la variable la ID de tu clave de acceso.
    • Nombre de la variable AWS_SECRET_KEY, valor de la variable tu clave de acceso secreto.
    • Nombre de la variable EC2_URL, valor de la variable la url de la región donde desees trabajar (consultar en Amazon Web Services General Reference), “https://ec2.eu-west-1.amazonaws.com“.

    Captura2

  2. Mirar los requisitos previos de la máquina virtual para AWS, de ahí el formato de disco anterior y el hecho de guardar sólo los discos.
  3. Exportar la imagen de la máquina virtual. Este paso ya se realizó anteriormente, sin embargo, se coloca en este puesto para recordar que no solo es posible importar en AWS imágenes creadas por una máquina virtual, sino que existen herramientas (VMWare Converter, Microsoft System Center Virtual Machine Manager, XenConvert…) para crear copias virtuales de un equipo físico.
  4. Importar imagen en AWS. Antes de importar, es importante recordar que se debe crear un bucket en el servicio S3 de AWS, donde se almacenará la imagen que subamos mediante comandos.
    Captura3
    El formato del comando a emplear debe ser el siguiente:

    ec2-import-instance disk_image_filename -f file_format -t instance_type -a architecture -b s3_bucket_name -o owner -w secret_key -p platform_name

    Cabe recordar que es importante consultar qué máquina está disponible en tu región, qué tipo de instancia es compatible con tu sistema (windows o linux), etc. Aunque se guardaran las credenciales de la cuenta con Amazon en las variables de entorno correspondientes, es necesario volver a especificarlas en el comando, así como el bucket de S3 creado anteriormente. A modo de ejemplo el comando lanzado en nuestro caso fue el siguiente:

    ec2-import-instance C:\Users\usuario\Desktop\Centos\CentOSMiami-disk1_gueno.vhd -f VHD -t m3.xlarge -a i386 -b cloud-master-benito -o ... -w ... -p Linux

    Captura4Captura5

  5. Manipular la instancia en AWS. Una vez subida la imagen, aparecerá automáticamente la instancia en Amazon EC2, sin embargo, el que sea automático no implica que no podamos manejarla como una instancia propia, es decir, se puede guardar una AMI y emplearla en instancias puntuales si se desea, se puede realizar implementar el autoescalado de AWS, etc.
    Captura6Captura7
    Con ello, lanzando una instancia puntual con dicha AMI y tomando su IP pública, comprobamos que la imagen es exacta a la de la máquina virtual, pero sin restricciones iniciales, tal como si se hubiera creado desde un principio en Amazon.Captura8
    El último paso a realizar es eliminar los datos del bucket de S3, ya que no son necesarios mantenerlos ahí por más tiempo.

Referencias:

 

 

Acceso mediante VNC a instancias Linux de AWS

Poder acceder a un ordenador con sistema operativo linux de forma gráfica puede ser interesante en muchos casos. Nos planteamos, por ejemplo el análisis de una red de nodos con la herramienta Gephi.  Para poder ejecutar este software en una instancia de AWS realizaremos los siguientes pasos. El grupo de seguridad debe permitir el acceso a los puertos 22 (SSH) y 5901 (VNC).

1. Conectaremos con la instancia mediante SSH.

2. Instalaremos los paquetes necesarios para el entorno gráfico, incluyendo el servidor VNC.

sudo apt-get update
sudo apt-get install ubuntu-desktop
sudo apt-get install vnc4server

3. Descargaremos el cliente VNC de la siguiente dirección

https://www.realvnc.com/download/

4. Lanzaremos el servidor SVNC

Podemos cambiar la geometría y el número de colores con los parámetros “-gometry  ” y “-depth”. Tenga en cuenta que a mayor definición de color y a mayor tamaño de pantalla la comunicación será algo más lenta.

vncserver -depth 24 -geometry 1366x768 :1

Para parar el servidor ejecutaremos

vncserver -kill :1

5. Configuración del cliente VNC

Para conseguir la misma calidad de color en el cliente debemos modificar una de las opciones de nivel experto.  Ejecutaremos VNC Viewer y haremos clic en el botón “Opciones“, a continuación haremos clic en la opción “Avanzadas…“. En la pestaña “Experto“, modificaremos la opción “ColorLevel” que cambiaremos a “full“.

2

Aceptaremos los cambios y en la ventana principal indicaremos el nombre de nuestro servidor añadiendo al final “:1″ y en cifrado seleccionaremos la opción “Dejar que VNC Server elija“.

1

Al intentar conectar utilizaremos el usuario por defecto de la instancia de AWS. Es importante que lancemos el servidor con este mismo usuario (en nuestro caso el usuario “Ubuntu“).  Es importante revisar los logs del servidor VNC para detectar posibles errores. Al conectar con el cliente VNC utilizaremos el password que introducimos durante la instalación de VNC. Si todo funcionó correctamente deberíamos ver una ventana “xterm” como esta.

2_1

6. Instalación del entorno gráfico xfce4
Si queremos además de esta ventana simple, poder acceder a un escritorio completo, utilizaremos en gestor de ventanas xfce4. Debido a un bug en gnome-session utilizando VNC hemos optado por instalar este gestor de ventanas algo más ligero. Puede consultar una guía completa de instalación de Xfce en esta dirección. Para instalar Xfce seguiremos los siguientes pasos.

sudo apt-get install xrdp
sudo apt-get install xfce4

A continuación, editaremos el fichero .vnc/xstartup y comentaremos la última linea y para añadir esta

# x-window-manager &
xfce4-session &

7. Instalación de Gephi

Para instalar Gephi, podemos utilizar la conexión ssh. Necesitaremos instalar java para lo que seguiremos los siguientes pasos:

java -version
sudo apt-get update
sudo apt-get install default-jre
sudo apt-get install default-jdk

Ahora podemos reiniciar el servidor VNC y volver a conectar con nuestro cliente. Si no hemos encontrado en el camino algún error, deberíamos poder acceder al gestor de ventanas de Xfce4 y descargar Gephi desde su página oficial y descomprimirlo utilizando una ventana “Xterm”. A continuación ejecutaremos “gephi” desde la carpeta “bin”.

3

Ahora que ya tenemos nuestro cliente y servidor configurados correctamente, podemos crear una imagen AMI que podremos utilizar cada vez que queramos trabajar con Gephi o cualquier otro software gráfico en Linux.

Referencias:

1. Ubuntu 13.10 – How to install xrdp in Ubuntu 13.10
http://c-nergy.be/blog/?p=4448

2. Wrong colours with a 16 depth
https://www.realvnc.com/pipermail/vnc-list/2000-March/012794.html

3. [SOLVED] Ubuntu Server VNC Server – Gray Screen
http://ubuntuforums.org/archive/index.php/t-1707906.html

4. Using VNC to Operate a Desktop on Ubuntu 12.04
https://www.linode.com/docs/applications/remote-desktop/using-vnc-to-operate-a-desktop-on-ubuntu-12-04

5. Setting Up VNC on Ubuntu in Amazon EC2 – Page 3 Page 3
http://www.serverwatch.com/server-tutorials/setting-up-vnc-on-ubuntu-in-the-amazon-ec2-Page-3.html

 

Instalación del servidor AI Challenge 2011 en una instancia de AWS

Seguiremos las instrucciones que el usuario “pixel8r” dejó en el foro oficial de la competición. Hemos podido comprobar que faltan algunas instrucciones que son importantes, sobre todo cuando se producen errores en la instalación (algo muy habitual) y hay que empezar de nuevo. En estos casos, hemos añadido ordenes que eliminan todos los usuarios y borran el directorio de instalación de chroot. Una cuestión importante es que este servidor utiliza virtualización ligera a través de schroot. Podemos encontrar más información sobre schroot en este enlace.

Es importante destacar que en el momento en el que se escribe este post no hemos conseguido que el servidor comienza a jugar partidas. En el hilo “Duplicating the aichallenge website locally” del  foro oficial de la competición se comenta que es necesario modificar dos ficheros (ver paso 18) y disponer de unos 20 usuarios con sus bots compilados y preparados para competir. Cualquier ayuda al respecto será bienvenida!

Ahora comenzaremos con los pasos seguidos para la instalación del servidor.

1. Lanzar una instancia en AWS utilizando las imágenes preconfiguradas de Ubuntu.
https://uec-images.ubuntu.com/releases/natty/release/
Elegir la opción “ebs”

eu-west-1
64-bit
ebs
Launch ami-7914170d
ec2-run-instances ami-7914170d -t t1.micro --region eu-west-1 --key ${EC2_KEYPAIR_EU_WEST_1}

2. Modificar los repositorios para incluir aquellos que permiten instalar paquetes de versiones anteriores de Ubuntu.
editar el fichero /etc/apt/sources.list dejar solo las siguientes lineas

deb http://old-releases.ubuntu.com/ubuntu/ natty main restricted
deb-src http://old-releases.ubuntu.com/ubuntu/ natty main restricted
deb http://old-releases.ubuntu.com/ubuntu/ natty-updates main restricted
deb-src http://old-releases.ubuntu.com/ubuntu/ natty-updates main restricted
deb http://old-releases.ubuntu.com/ubuntu/ natty universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ natty universe multiverse
deb http://old-releases.ubuntu.com/ubuntu natty-security main restricted
deb-src http://old-releases.ubuntu.com/ubuntu natty-security main restricted

3. Actualizar apt-get

apt-get update

4. Instalar git

apt-get install git

5. Crear usuario contest

sudo useradd -d /home/contest -m -s /bin/bash contest
passwd contest

El password será contest

6. Convertir al usuario contest en administrador
Ejecutar

sudo visudo

y añadir la siguiente linea al final de fichero

contest ALL=(ALL) ALL

7. Editar el fichero /etc/hosts
Añadiremos las siguientes lineas. sustituiremos <ip> por la IP asignada por AWS.

127.0.0.1 ec2-<ip>.eu-west-1.compute.amazonaws.com
127.0.0.1 aichallenge

8. Cambiar el nombre del host a aichallenge

sudo hostname aichallenge

9. Clonar el repositorio git de aichallenge

sudo su - contest
git clone https://github.com/aichallenge/aichallenge.git

9. Añadir módulos y actualizaciones

cd aichallenge
git submodule init
git submodule update

10. Eliminar lenguajes de programación no necesarios

Algunos lenguajes de programación no se instalan correctamente (por ejemplo Ruby) . Si no
necesita los lenguajes de programación adicionales, elimine todos lo que aparece en el fichero setup/retrieve_languages.py en la linea “sources=” y entre “[" y "]“. Deje aquellas lineas que necesite realmente.

editar el fichero setup/retrieve_languages.py
y eliminar todas las lineas que hay dentro de sources = []

11. Configuración el servidor

Ejecutaremos lo siguiente y responderemos a las preguntas como se indica.

su - contest
cd ~/aichallenge
sudo python setup/server_setup.py

Are you sure you want to continue? yes
- Only install system packages? no
- Contest username [contest] – push ENTER to accept default
- Database root password? – Leave blank
- Confirm database root password? – leave blank
- Contest database username [contest] – push ENTER
- Contest database password: contest
- Confirm contest database password: contest
- Name of contest database [aichallenge] – push ENTER
- accept defaults for root dir, source repo, uploads, maps & replays
- hostname is whatever you set above ec2-<ip>.eu-west-1.compute.amazonaws.com
- Make contest site the default website? yes
- Run setup as configured above? yes

12. Probar que el servidor está funcionando

en un navegador escribir el nombre del servidor

http://ec2-<ip>.eu-west-1.compute.amazonaws.com

Si todo funciona debe aparecer la página principal de la competición.

Instalación del WORKER
Los workers (podemos ejecutar más de uno) se encargan de compilar los bots y comprobar que el resultado de la compilación ha sido correcta. Si hubiese algún error en la compilación, este se muestra en el panel del usuario.

13. Editar el fichero de configuración

Editar el fichero setup/worker_setup.py

aquí también debemos eliminar aquellos lenguajes de programación que no necesitemos del método “install_extra_distribution_languages()” y comentar aquellas lineas que no necesitemos del “install_” del método “install_extra_distribution_languages().

En el método “install_extra_distribution_languages():” además, hemos editado la lista pkg_list dejando solo ["perl"]. También eliminaremos las lineas siguientes que provocan un error en la instalación de Ruby.

install_apt_packages(pkg_list)
if not os.path.exists(“/usr/bin/ruby”):
os.symlink(“/usr/bin/ruby1.9.1″, “/usr/bin/ruby”)

En el método “install_basic_languages()” eliminaremos de la lista pkg_list “python3-dev”, quedando de esta forma:
pkg_list = ["gcc", "g++", "openjdk-6-jdk", "python-dev", "python-numpy", "python-scipy"]

Como se indica anteriormente eliminaremos las lineas siguientes:
install_clojure(download_base)
install_dart(download_base)
install_dmd(download_base)
install_golang(download_base)
install_groovy(download_base)
install_nodejs(download_base)
install_coffeescript(download_base) # must come after nodejs
install_pypy(download_base)
install_racket(download_base)
install_scala(download_base)

NOTA: Editar las variables “src_url” y “os_url” sustituyendo sus valores por estos:

“src_url”: “http://old-releases.ubuntu.com/ubuntu/”,
“os_url”: “http://old-releases.ubuntu.com/ubuntu/”,

Esto soluciona uno de los errores comentados en el foro oficial de Ai Challenge Ants 2011.

14. Lanzar el Worker

Para lanzar el worker ejecutaremos:
curl http://ec2-<ip>.eu-west-1.compute.amazonaws.com/api_server_setup.php?|sh

Esta operación tarda varios minutos y es aquí dónde se crea el entorno virtual para la ejecución de los bots. Es posible que se produzca algún fallo en esta fase, principalmente porque elegimos un lenguaje de programación que requiere de algún paquete no disponible. Tenga en cuenta que estamos intentando instalar un sistema operativo del año 2011 y que es muy posible que ciertos paquetes no estén disponibles en la misma ubicaciones. Dependiendo del momento en el que se produzca el error es posible que tengamos que eliminar los usuarios jailuser necesarios para la ejecución protegida de los bots.

deluser jailuser1;deluser jailuser2;deluser jailuser3;deluser jailuser4;deluser jailuser5;deluser jailuser6;deluser jailuser7;deluser jailuser8;deluser jailuser9;deluser jailuser10;deluser jailuser11;deluser jailuser12;deluser jailuser13;deluser jailuser14;deluser jailuser15;deluser jailuser16;deluser jailuser17;deluser jailuser18;deluser jailuser19;deluser jailuser20;deluser jailuser21;deluser jailuser22;deluser jailuser23;deluser jailuser24;deluser jailuser25;deluser jailuser26;deluser jailuser27;deluser jailuser28;deluser jailuser29;deluser jailuser30;deluser jailuser31;deluser jailuser32

También debemos borrar el directorio en el que se crea el espacio virtual

rm -fr /vsr

Después de realizar estas dos operaciones, podemos volver a lanzar el worker.

AJUSTES FINALES

15. Instalar phpMyAdmin
Instalaremos phpMyAdmin versión 3.4.3.2 (la versión del 2011, las más modernas fallan con ubuntu 11.04)

http://sourceforge.net/projects/phpmyadmin/files/phpMyAdmin/3.4.3.2/

16. Editamos el fichero /etc/apache2/

vi /etc/apache2/sites-available/ec2-<ip>.eu-west-1.compute.amazonaws.com

Añadimos las siguientes lineas a partir de la linea 52

Alias /phpmyadmmin /home/contest/phpmyadmin
<Directory /home/contest/phpmyadmin>
Options Indexes FollowSymLinks MultiViews
AddEncoding x-gzip .replaygz
AddType application/json .replay .replaygz
AllowOverride None
Order allow,deny
Allow from all
</Directory>

ejecutamos

/etc/init.d/apache2 restart

y volvemos a ejecutar el worker

sudo -u contest /home/contest/aichallenge/worker/start_worker.sh

Accedemos a phpMyAdmin

http://ec2-<ip>.eu-west-1.compute.amazonaws.com/phpmyadmin

con el usuario contest y el password contest

17. Instalar los mapas

En la dirección http://ants.aichallenge.org/using_the_tools.php copiamos la dirección del enlaces http://ants.aichallenge.org/tools.tar.bz2

y descargamos en el servidor el fichero

wget http://ants.aichallenge.org/tools.tar.bz2

Descomprimimos el fichero

bzip2 -d tools.tar.bz2
tar xvf tools.tar

copiamos el directorio tools a /home/contest y cambiamos los permisos

chown -R contest:contest tools/

Copiamos las carpetas maze, multi_hill_maze, and random_walk folders to ~/maps

cp -r tools/maps/maze/ maps/.
cp -r tools/maps/multi_hill_maze/ maps/.
cp -r tools/maps/random_walk maps/.
cd ~/aichallenge/manager
./add_maps_to_database.py

18. Modificar los ficheros sql/2_generate_matchup.sql
y sql/opponent.sql

NOTA: Los números de lineas que aquí se indican no coinciden con las que aparecen en las instrucciones del foro. Las últimas modificaciones del repositorio de Ai Challenge Ants en Github son de febrero de 2012, sin embargo las instrucciones del foro son de octubre de 2011 por lo que suponemos que posteriores modificaciones en estas líneas provoca esta variación en las numeraciones. Hemos realizado prueba con y sin las modificaciones.

Modificar la linea 169 del fichero 2_generate_matchup.sql y
cambiar la linea select min(g.game_count) por select avg(g.game_count) * 1.1 + 1
guardar y salir.

mysql -u contest -p -D aichallenge < 2_generate_matchup.sql

a continuación modificar la linea 205 del fichero opponent.sql

cambiar la linea select min(g.game_count) por select avg(g.game_count) * 1.1 + 1
guardar y salir

mysql -u contest -p -D aichallenge < opponent.sql

19. Ejecutar update_visualizer

cd ~/aichallenge/setup
sudo ./update_visualizer.sh

http://ec2-<ip>.eu-west-1.compute.amazonaws.com/api_get_task.php?api_key=490c55f4e6002cab90695cdc688f8c64

Si todo funcionó correctamente, debemos poder ver como cada vez que se añade un nuevo código, el worker lo compilará mostrando posibles errores.

Auto escalado y balanceo de carga con AWS

Los grupos de auto escalado de AWS (http://aws.amazon.com/es/autoscaling/) van a permitir escalar horizontalmente un servidor web o cualquier otro servicio. En AWS podremos definir reglas que permitirán que el número de servidores que ofrecen un servicio se adapten de forma automática a las necesidades de los usuarios del servicio. En el ejemplo que vamos a ver a continuación crearemos un grupo de autoescalado para un servidor web.

Lo primero que haremos será instalar una herramienta que permita poner a prueba nuestro servidor. Podemos encontrar diferentes tipos de Herramientas de pruebas para servidores web si buscamos en Google la cadena “stress test tool http”  podemos encontrar algunos ejemplos. De entre ellos utilizaremos Siege que es una herramienta muy sencilla y que nos servirá para poner a prueba nuestro servicio web.

 

1. Crear el balanceador de carga.

load_balancer_1  load_balancer_2_2  load_balancer_3_2 load_balancer_4 load_balancer_5 load_balancer_6 load_balancer_7

2. Crear una configuración de lanzado (Launch Configuration)

auto_scaling_1 auto_scaling_2 auto_scaling_3 auto_scaling_4 auto_scaling_5 auto_scaling_6 auto_scaling_7 auto_scaling_8 auto_scaling_9 auto_scaling_10 auto_scaling_11 auto_scaling_12

3. Configuración del cliente Siege

auto_scaling_grp_29 auto_scaling_grp_30 auto_scaling_grp_31

3.2 Conexión con la instancia utilizando Putty

auto_scaling_grp_32 auto_scaling_grp_33 auto_scaling_grp_34 auto_scaling_grp_35 auto_scaling_grp_36 auto_scaling_grp_37 auto_scaling_grp_38 auto_scaling_grp_39 auto_scaling_grp_40 auto_scaling_grp_41 auto_scaling_grp_42 auto_scaling_grp_43

3.1 Instalación de Siege

auto_scaling_grp_44 auto_scaling_grp_45 auto_scaling_grp_46 auto_scaling_grp_47 auto_scaling_grp_48 auto_scaling_grp_49 auto_scaling_grp_50 auto_scaling_grp_51 auto_scaling_grp_52 auto_scaling_grp_53 auto_scaling_grp_54 auto_scaling_grp_55

4. Preparación del cliente para las pruebas de estres

http://yourdomain.com/path/to/script.php?argument1=arg1&argument2=arg2

C:\aws>python ez_setup.py

Código para programa php

<HTML>
<HEAD>
</HEAD>
<BODY>
<?php
$max = $_GET['max'];

for ($x = 0; $x <= $max; $x++) {
 echo "The number is: $x <br>";
} 
?>
</BODY>
</HTML>

 

Referencias

1. Set Up a Scaled and Load-Balanced Application
http://docs.aws.amazon.com/AutoScaling/latest/DeveloperGuide/as-register-lbs-with-asg.html

2. Elastic Load Balancing in Amazon EC2-Classic
https://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/UserScenariosForEC2.html

 

Instalar AWS CLI en Windows 7

AWS CLI (Command Line Interface) es un interfaz unificado para acceder a los diferentes servicios de Amazon en la nube. Podemos encontrar más información sobre AWS CLI en los siguientes enlaces:

Para poder ejecutar comandos de AWS CLI necesitamos instalar previamente Python.

PASO 1: Instalar Python

Por cuestiones de compatibilidad recomendamos instalar la versión 2.7

Para descargarlo: https://www.python.org/downloads/

En nuestro caso seleccionaremos la versión Windows X86-64 MSI Installer ya que nuestro sistema operativo es de 64 bits.

PASO 1.2: Conocer el tipo de sistema
Para saber si nuestro sistema es o no de 64 bits, haremos clic con el botón izquierdo sobre inicio derecho del ratón sobre el menú Inicio -> Equipo 
inicio_windows  y después haremos clic con el botón derecho sobre el menú Equipo. Posteriormente clic con el botón izquierdo sobre el submenú Propiedades.

submenu_propiedades2

Aparecerá la siguiente información. En la sección Tipo de sistema, podremos ver si nuestro sistema es de 64 o de 32 bits.

propiedades_64bits

Para instalar Python, simplemente debemos hacer clic primero en Ejecutar y después en Next hasta completar la instalación.

python_install_1 python_install_2 python_install_3 python_install_4 python_install_5python_install_7

Una vez completada la instalación, debemos añadir la ruta de Python al “Path” del sistema para que podamos ejecutar Python desde cualquier directorio.

PASO 1.3: Añadir Python a la variable de entorno “PATH”

Para añadir este cambio de forma permanente, debemos volver a acceder a las propiedades del equipo de la misma forma que lo hicimos en el PASO 1.2: Conocer el tipo de sistema, pero esta vez seleccionaremos la opción “Configuración avanzada del sistema” a continuación haremos clic sobre “Variables de entorno”.

cambiar_path2

 

cambiar_path4cambiar_path5

En la ventana de “Variables de entorno” editaremos la variable “Path” haciendo clic en el botón Editar. Añadiremos los siguiente: “;C:\Python27;C:\Python27\Scripts” a continuación de la cadena que tuviésemos previamente. Si no hubiese ningún texto eliminaremos el “;” de inicio de la cadena.

PASO 1.4 Abrir una ventana de comandos de Windows

Una vez realizado este cambio comprobaremos Python está instalado, haciendo clic sobre el botón de inicio de Windows inicio_windows y escribiendo “cmd” en la casilla etiquetada como “Buscar programas y archivos”.

cmd2

En la ventana de comando escribiremos python. Si todo es correcto debe aparecer el siguiente mensaje:

Python 2.7.8 (default, Jun 30 2014, 16:08:48) [MSC v.1500 64 bit (AMD64)] on win32

Type "help", "copyright", "credits" or "license" for more information.
>>>

Para salir de esta ventana escribiremos “Ctrl+z”, después pulsaremos la tecla “Enter” y a continuación escribiremos “exit” y “Enter” o bien haremos clic sobre el símbolo “x” de la esquina superior derecha de la ventana.

cmd_python

PASO 2. Instalación de Python Package Index (Pip)

Pip es una herramienta que nos permite instalar paquetes en Python facilmente. Crearemos el directorio c:\aws para guardar los ficheros necesarios para la instalación de AWS CLI.
A continuación descargaremos el fichero “ez_setup” de la siguiente dirección
https://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py
y lo guardaremos en c:\aws

A continuación ejecutaremos desde una ventana de comandos de windows

C:\aws>python ez_setup.py

a continuación ejecutaremos

C:\aws>pip install awscli

PASO 3: Configuración de AWS CLI

Para configurar AWS CLI necesitamos nuestra “AWS Access Key ID” y “AWS Secret Access Key“, además de la región a la que deseamos acceder (por ejemplo: eu-west-1).

La forma más sencilla de configurar AWS CLI es escribiendo lo siguiente en una ventana de comandos de windows

c:\aws\aws configure
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: eu-west-1
Default output format [None]: text

 

Una vez configurado escribiremos lo siguiente para probar que la configuración es correcta:

c:\aws\aws ec2 describe-instances --output table --region eu-west-1

Si todo es correcto, el sistema mostrará una tabla similar a esta:

-------------------
|DescribeInstances|
+-----------------+
$ aws ec2 describe-instances --output table --region us-west-1
-------------------
|DescribeInstances|
+-----------------+
$ aws ec2 describe-instances --output table --region us-west-2
------------------------------------------------------------------------------
|                              DescribeInstances                             |
+----------------------------------------------------------------------------+
||                               Reservations                               ||
|+-------------------------------------+------------------------------------+|
||  OwnerId                            |  012345678901                      ||
||  ReservationId                      |  r-abcdefgh                        ||
|+-------------------------------------+------------------------------------+|
|||                                Instances                               |||
||+------------------------+-----------------------------------------------+||
|||  AmiLaunchIndex        |  0                                            |||
|||  Architecture          |  x86_64                                       |||

Referencias:

AWS Command Line Interface

http://docs.aws.amazon.com/cli/latest/userguide/installing.html

Configuring the AWS Command Line Interface

http://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html