Una aplicación con Docker

Hoy la mayor parte de las aplicaciones que nos dan servicio a través de móviles o navegadores residen en la «nube», y en el fundamento de esta, de la «cloud», están los «contenedores». De lo que se trata es de poder manejar aplicaciones muy diferentes de la misma manera, el contenedor es un simil extraido de la manera en que se transportan mercancías de todo tipo por el mundo. Docker es probablemente la tecnología de contenedores mas difundida.

La clave del contenedor es la virtualización, que permite que quien gestiona la aplicación se desentienda de sus peculiaridades. La virtualización posibilita dos cosas:

  • Una gestión sencilla de aplicaciones en los servidores: desde el punto de vista del operador todas las aplicaciones son solo contenedores, sin importar la tecnología que haya dentro, todas se arrancan, se apagan y configuran de la misma manera.
  • Un despliegue de aplicaciones sin complicaciones: si funciona en tu ordenador, funcionará en el servidor; es el mundo DevOps.

Probablemente el éxito de los contenedores esté en que realizan una virtualización muy ligera. Cuando una aplicación se despliega en un contenedor no corre sobre una máquina virtual que incluye todo un sistema operativo. Un contenedor incluye la aplicación y tan solo las librerías de sistema que realmente necesita.

En esta entrada vamos a ver como crear una aplicacioncita, meterla en un contenedor y arrancarla. La aplicación de ejemplo usa tecnología Java y el sistema es Linux Ubuntu, pero la combinación podría ser cualquier otra.

Para empezar necesitamos Docker instalado en el equipo. Para instalar la Community Edition de Docker para Ubuntu (64 bits) se puede seguir lo indicado aquí.

Al terminar podemos probar que la instalación ha ido bien:
$ sudo docker run hello-world

pasted_image

Este comando trata de ejecutar una imagen de contenedor llamada “hello-world”. Como no la tiene se la descarga del repositorio por defecto y luego la ejecuta sobre el motor Docker. La aplicación muestra un saludo en texto.

Ahora vamos a crear la aplicación «misaludo». Creamos un directorio con la estructura típica de un programa Java:
$ mkdir -p misaludo/src/main/java/hola

Creamos un fichero pom.xml, el descriptor de este aplicativo. Como usamos Java nos valemos de Maven para construirlo, pero podría haber sido una aplicación Node usando NPM, o una PHP usando Composer… la tecnología del programa que corre dentro del contenedor puede ser cualquiera.

Abrimos un editor y creamos el pom.xml:
$ vim misaludo/pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

<groupId>org.miorganizacion</groupId>
 <artifactId>mi-spring-boot-docker</artifactId>
 <version>0.1.0</version>

<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>1.5.2.RELEASE</version>
</parent>

<properties>
 <java.version>1.8</java.version>
</properties>

<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
</dependencies>

<build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
</build>

</project>

Entre las dependencias de este ejemplo tenemos Spring Boot, un framework que permite construir programas que hacen muchas cosas con poco esfuerzo. «misaludo» será una aplicación web que devuelve el mensaje «¡Hola Docker!».

Ahora podemos crear la aplicación abriendo un editor y copiando el código que sigue a continuación:
$ vim misaludo/src/main/java/hola/Aplicacion.java

package hola;


import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;


@SpringBootApplication
 @RestController
 public class Aplicacion {


@RequestMapping("/")
 public String home() {
 return "¡Hola Docker!";
 }


public static void main(String[] args) {
 SpringApplication.run(Aplicacion.class, args);
 }
 }

Construimos a continuación el programa con Maven y lo probamos (hay que tener Maven y Java 8 instalado, si no lo tienes puedes seguir lo dicho aquí y aquí)
$ mvn package && java -jar target/mi-spring-boot-docker-0.1.0.jar

El programa levanta un servidor web Tomcat conteniendo nuestra aplicación. Si vamos al navegador y ponemos localhost:8080 veremos el saludo.

pasted_image002

Hemos creado y probado el programa. Ahora vamos a preparar su contenedor, lo construiremos y lo arrancaremos para comprobar que llegamos al mismo resultado.

Docker usa un fichero Dockerfile como descriptor del contenedor. Creamos el fichero Dockerfile:
$ vim misaludo/src/main/docker/Dockerfile

FROM frolvlad/alpine-oraclejdk8:slim
 VOLUME /tmp
 ADD mi-spring-boot-docker-0.1.0.jar app.jar
 RUN sh -c 'touch /app.jar'
 ENV JAVA_OPTS=""
 ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar" ]

En Dockerfile se indica en ADD que ejecutable se añade al contenedor, y en la entrada ENTRYPOINT como ejecutarlo.

Para construir la imagen docker (el contenedor) podemos usar Maven. Se añade al pom.xml una propiedad indicando el prefijo que ayuda a identificar el contenedor, y un plugin de construcción que sabe como como crear imágenes.

<properties>
 [...]
 <docker.image.prefix>clublasindias</docker.image.prefix> </properties>


<build>
 <plugins>
 [...]
 <plugin>
 <groupId>com.spotify</groupId>
 <artifactId>docker-maven-plugin</artifactId>
 <version>0.4.9</version>
 <configuration>
 <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
 <dockerDirectory>src/main/docker</dockerDirectory>
 <resources>
 <resource>
 <targetPath>/</targetPath>
 <directory>${project.build.directory}</directory>
 <include>${project.build.finalName}.jar</include>
 </resource>
 </resources>
 </configuration>
 </plugin>
 </plugins>
</build>

Antes de indicar a Maven que construya el contenedor necesitamos el motor Docker arrancado:
$ sudo service docker start

A partir de lo indicado en el pom.xml nuestro contenedor tendrá por nombre clublasindias/mi-spring-boot-docker. Para construirlo hacemos:
$ mvn package docker:build

Arrancamos el contenedor de la siguiente manera:
$ sudo docker run -p 8080:8080 -t clublasindias/mi-spring-boot-docker

Si ahora vamos en el navegador a localhost:8080 veremos el saludo «¡Hola Docker!» que ahora es ofrecido por el contenedor. ¡Aplausos! :)

Si hacemos sudo docker ps veremos la nueva imagen corriendo en el motor docker:

pasted_image003

 

Referencia: https://spring.io/guides/gs/spring-boot-docker/

Usando Atom para Node.js

Node es una plataforma que me gusta para hacer pruebas de concepto, porque con poco código es fácil hacer muchas cosas.

Buscando un editor he empezado a utilizar Atom. Viniendo como vengo de Java, estoy familiarizado con entornos como Eclipse o IDEA de JetBrains, pero me apetecía practicar con algo mas ligero. Vim es otro editor que manejo bien y me gusta, pero no lo veo para esto. Me encanta para editar rápidamente sobre la línea de comando, pero no para desarrollar de forma continua.

Atom es sencillo, es bonito, es abierto, y tiene una comunidad muy rica detrás. No es tan rápido como Sublime y Visual Studio Code, pero me da igual.

En un sistema Linux como Ubuntu la instalación es la habitual con su gestor de paquetes. En la sección Atom Basics del manual de Atom se describen los comandos básicos para desenvolverse en el editor, en caso de duda un “Ctrl+Shift+P” te permite encontrar lo que necesites.

Una de las características de Atom es que es muy personalizable, existe multitud de extensiones disponibles para adaptarlo a tus necesidades. La instalación de estos paquetes se puede hacer con un “apm install <nombre-de-paquete>“.

Las que siguen son las extensiones que he encontrado mas útiles para desarrollar programas en servidor. He ignorado las que tienen que ver con la parte de presentación como autoclose-html, pigment o color-picker.

Las primeras en mi lista son atom-ternjs, node-debugger y script. Para mí son las mas necesarias, y las primeras que he instalado.

atom-ternjs

  • Acostumbrado a trabajar en IDEs como Eclipse algo que busco de forma natural es una utilidad de autocompletado de código y de chequeo de sintaxis. Esto es lo que encuentras en esta extensión. Como indica su documentación, si quieres usarla en tu proyecto, debes añadirle un fichero de configuración para tern donde le puedes indicar como quieres que te ayude.

node-debugger

  • Esta extensión es un depurador para Node con las funciones habituales de inserción de puntos de ruptura, ejecución paso a paso y consulta de pila de llamadas, entre otras.

script

  • Esto es una pequeña maravilla que te permite seleccionar un trozo de código y ejecutarlo en un momento. Algo como https://repl.it/ pero dentro de Atom. Ideal para prototipar una función o para probar con rapidez.

Otro grupo de extensiones que uso son las que me ayudan a editar mas rápidamente, porque visualizo mejor las cosas, o porque llego a ellas mas rápidamente: minimap, open-recent, highlight-selected, file-icons, maximize-panes, fold-lines y tool-bar.

minimap

  • Muestra a la derecha del editor una visión resumida de todo el código contenido en el fichero, permitiendo situarte con mas facilidad. Existen extensiones relacionadas con esta que permiten indicar la posición del cursor en el minimapa.

open-recent

  • En el menú de fichero muestra siempre los ficheros y carpetas que hemos abierto mas recientemente.

highlight-selected y minimap-highlight-selected

  • Al seleccionar una variable o una palabra clave, todas las ocurrencias de las mismas en el fichero aparecen resaltadas.

file-icons

  • Asocia un icono para cada extensión de fichero facilitando encontrar lo que buscas.

maximize-panes

  • Permite maximizar el panel del editor donde estás trabajando sin cerrar el resto de paneles.

fold-lines

  • Permite compactar en una línea distintos bloques de código para facilitar la lectura.

tool-bar

  • Aunque me encanta usar atajos de teclado, mi magia es limitada y necesito de una barra de herramientas como esta. Permite personalizar su contenido.

Y ahora este grupo final de plugins que veo interesantes. Puedo vivir sin ellos pero les he dado una oportunidad: linter, auto-detect-indentation y atom-beautify.

linter y linter-eslint

  • Es una extensión para corrección de código que también se integra en otros entornos de desarrollo. linter es el paquete base que soporta HTML, CSS y JavaScript. linter-eslint es una ampliación sobre el anterior específico para JavaScript y JSX. Como en el caso de tern, para usarlo en tu proyecto debes incluir un fichero de configuración eslint donde puedes detallar, por ejemplo, si se va a programar en JavaScript ES6 o con una versión anterior.

auto-detect-indentation y atom-beautify

  • El primero configura la identación del fichero basado en el contenido que ya tiene, no solo en las settings del editor. El segundo organiza el código para verlo mejor.

Y tras tanta personalización, ¿que pasa si quieres llevártela a otra máquina, quieres compartirla, o simplemente no perderla? Pues usar otra extensión: sync-settings.

syn-settings

  • Permite guardar la personalización realizada en el editor en un gist de GitHub. Hay que tener una cuenta disponible. Para hacer el backup hay que introducir en Atom el token de acceso a GitHub y el ID del gist donde vas a hacerlo. Aquí puedes encontrar la configuración descrita en este post.

En Internet hay muchas páginas mostrando conjuntos de extensiones preferidas para distintos usos. Aquí he compartido las mías.

Node.js y el Event Loop

Una de las razones que ha hecho popular a Node.js es su extraordinaria velocidad de respuesta en comparación con un servidor Java (por ej. Tomcat). Obviamente esto no se consigue gratis, y es que a diferencia de un servidor Java, Node.js es “single threaded” solo hay un hilo de ejecución atendiendo todas las peticiones, no se levanta uno nuevo cada vez. Esto elimina toda la sobrecarga de gestión de los hilos (locks y demás).

Pero para que esto funcione las aplicaciones tienen que ser programadas de forma que no se bloqueen en tareas lentas como una consulta a la red, un acceso base de datos o a un fichero. Es por ello que la programación asíncrona está en el fundamento de Node.js. Node.js es una apuesta a que un solo hilo con procesado asíncrono tiene mejor rendimiento y escalabilidad que una implementación multi-hilo.

Programación síncrona

Node.js se apoya en un motor de ejecución javascript como el que contiene cualquier navegador. Este motor es el que es single-threaded, y en el navegador es la razón de que si tienes una página y tu código realiza varias llamadas de red síncronas que tardan mucho, acabes con una página que se queda bloqueada y donde no puedes hacer click en ningún sitio.

Es el mismo problema que tenemos en Node.js si hiciéramos muchas llamadas síncronas costosas (base de datos, ficheros, red). No habría respuesta hasta finalizadas todas las tareas.bloqueos_node

La forma de evitar los bloqueos es con programación asíncrona y en un navegador como Chrome esto es posible porque aparte del hilo de ejecución del motor javascript hay otros hilos de gestión. Entre ellos el famoso Event Loop. ¿Cómo funciona?

Programación asíncrona y el Event Loop

Cuando se ejecuta un código javascript en una página, de forma síncrona, usa la pila de llamadas del motor. Los métodos invocados se van apilando y desapilando y solo se devuelve el control al navegador cuando la pila se vacía. En este modo síncrono, si hay tareas que tardan mucho, podemos vernos con que la página se “congela” durante un buen rato.

callstack_sincrono

Si realizamos tareas de forma asíncrona, como cuando invocamos el API setTimeOut pasando una función de callback y un retardo, esta es ejecutada por un hilo independiente del navegador, fuera de la pila de Javascript. Cuando termina de ejecutarse la función de callback queda en una cola, a la espera de poder ejecutarse.

callstack_asincrono

¿Cuando se ejecuta la función de callback? En cuanto la pila se libera otro hilo de gestión del navegador, el famoso Event Loop, coge la función para meterla en la pila.

Por todo lo anterior es que se usa ese truco de llamar a funciones pasándolas a setTimeOut con delay 0. Las funciones no se ejecutan directamente, sino que acaban en una cola, y el loop irá pasándolas a la pila cada vez que se vacíe. En esos huecos en medio la página responde a nuestras acciones, no está bloqueada. Provocamos asincronía y creamos páginas mas dinámicas.

APIs asíncronas como setTimeOut hay muchas: para llamadas en red, consulta de almacenes de datos, etc.

Node.js resuelve la programación asíncrona como hemos descrito antes para el navegador. Y es que Node.js usa el motor javascript en que se basa Chome, y los procesos de gestión alrededor del motor son como los que usa el navegador.

chromeVer también:

Test plugin wp-gnusocial

Esto es un test del plugin wp-gnusocial. Permite usar gnusocial como plataforma de comentarios a partir de la publicación de un post. Los comentarios aparecen tanto en gnusocial como en wordpress. El plugin todavía en pruebas >> git://enkidu.coop/wp-gnusocial.

Si todo va bien este post aparecerá publicado en liberakampo.org …

 

Unete a la federación con GNU-Social

Esta semana he instalado un sitio de microblogging con gnu-social donde queremos cacharrear y aprender. Lo he llamado Libera Kampo. Si os suena raro es porque quereis ;-). Es Esperanto  y es sencillo de aprender.

GNU-Social es un software de redes sociales de código abierto y gratuito. Básicamente te permite crear tu propia red social dedicada a lo que desees y que esta a su vez forme parte de una red mas extensa compuesta por todos los nodos GNU-Social que existen en el mundo. Desde un nodo puedes tener conversaciones con la gente registrada en ese nodo o también con personas registradas en otros.

gnu

Continúa leyendo Unete a la federación con GNU-Social

De la pizarra a la base de datos –> Neo4j

He de confesar que quizá no sea muy objetivo a la hora de comparar una base de datos orientada a grafos con otras NoSQL. Para aprender algo nuevo suelo visualizar relaciones, y en general tiendo a fijarme menos en los detalles y mas en que papel cumplen unas cosas respecto a otras.

un grafo

Y resulta que estos almacenes de datos me dan lo que me gusta, su foco está puesto en las relaciones, y de forma muy sencilla puedo convertir el dibujito de cajitas y flechas que tengo en la cabeza en una base de datos real. Apenas hay un salto o traducción.

Continúa leyendo De la pizarra a la base de datos –> Neo4j

Humongous Mongo

Parece ser que el nombre de Mongo DB se deriva del término humongous que viene a significar algo así como “enorme” o “monstruoso”, quizá por su habilidad para tratar grandes cantidades de datos y peticiones. Yo, la primera vez que oí este nombre pensé en el planeta Mongo de los comics de Flash Gordon :-P Ejemplos de lugares donde se usa Mongo son Foursquare, Bitly o el CERN para almacenar los datos del LHC.

flash-gordon-mapa-mongo

Esta BD open source NoSQL, es de las llamadas “documentales”. En una base de datos relacional cada cliente en una tabla de clientes, tiene siempre los mismos campos, nombre, apellidos, dni… en una BD documental, hoy un cliente de la colección clientes tiene quizá 10 campos, si el mes que viene nos damos cuenta de que los nuevos clientes necesitan 12, no hay problema, simplemente insertamos los nuevos con 12 campos. Es una BD sin un esquema que restrinja (o garantice) una estructura. Más libertad para el usuario, pero también más responsabilidad.

Continúa leyendo Humongous Mongo