Desde hace mucho tiempo todos los desarrolladores de infraestructura se han preocupado por el manejo de ambientes estables en cada una de las fases de desarrollo de una aplicación y más aún cuando es un conjunto de frameworks, servicios, serverless, frontends desarrollados en diversos lenguajes, etc.

Afortunadamente en la actualidad se han venido desarrollando bajo el concepto de DevOps (Developments and Operations) una serie de tecnologías que cada día hacen más fácil nuestro trabajo como proveedores de estabilidad en los ambientes.

La primer herramienta de la que debemos de hablar es sin duda Docker y su capacidad de usar contenedores de infraestructura, y como es esto posible, como funciona?

Ahora bien, que entendemos por contenedor, pues tenemos que verlo como instancias de ejecución de una imagen, así es es como una pequeña maquinita tipo VM que tiene lo que necesitamos para poder correr imágenes de algo, ahora bien, que entendemos como imagen en este contexto, pues debemos verlo como un snapshot de una máquina virtual, o como las imágenes de puntos de restauración de windows, algo muy similar.

Ahora como creo esta famosa imagen, la respuesta es mediante un Dockerfile el cual es un archivo de configuración que se utiliza para crear estas imágenes. En dicho archivo indicamos qué es lo que queremos que tenga la imagen, y los distintos comandos para instalar las herramientas.

Ahora bien vamos a empezar con un pequeño ejemplo de lo que llevamos hasta ahorita. Para ello necesitaremos Instalar Docker en nuestra computadora.

OK, una vez lo tenemos, vamos con este ejemplo para esto usaremos un simple index.html, un archivo que llamaremos default.conf y nuestro Dockerfile.

default.conf

server {
  listen       80;
 
  location / {
    root   /usr/share/nginx/html;
    index  index.html index.htm;
  }
}

index.html

< !DOCTYPE html >
< html lang="en" >
	< head >
		< meta charset="utf-8" >
		< meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" >
	< /head >
	< body >
		Hello world!!
	< /body >
< /html >

Dockerfile

#Correr con una image de nginx alpine que son más livianas
 FROM nginx:alpine
#Copiar el archivo default.conf a la carpeta de configuración del nginx
 COPY default.conf /etc/nginx/conf.d/default.conf
#Copiar el archivo index a la carpeta por defecto de despliege del server nginx
 COPY index.html /usr/share/nginx/html/index.html
#Correr y no parar ni recibir peticiones
 CMD ["nginx", "-g", "daemon off;"]

Y listo, aunque no lo crean esto es lo único que necesitaremos, ahora veamos que tenemos nuestro primer Dockerfile. Donde simplemente declaramos que queremos obtener de DockerHub (Lo veremos pronto) una imagen del Nginx, el es un servidor web de código abierto que, desde su éxito inicial como servidor web, ahora también es usado como proxy inverso, cache de HTTP, y balanceador de carga, luego copiamos los archivos de default e index a sus respectivas carpetas en nginx y por último con CMD lo ponemos a correr indefinido.

Bien bien muy bonito el archivo y todo pero y cómo lo ponemos a correr, bueno antes que nada les diré cómo trabaja y en el proceso comandos básicos.

Bueno resulta que esta herramienta tiene su propio repositorio, su propio cliente y su propio servicio por decirlo así, del lado del cliente tenemos a través de nuestra línea de comandos una serie de instrucciones como lo son BUILD, PULL, PUSH y RUN estas primeras instrucciones base nos ayudan a crear, obtener, subir a un repositorio y correr nuestras imágenes creadas con nuestros Dockerfile o con imágenes públicas, cada vez que ejecutamos una instrucción de estas del lado del servidor hay un DAEMON que escucha a través de un API esta petición y las ejecuta, si la instrucción es un pull, entonces va a el registry (con repositorio) y nos provee la imagen solicitada, y si es un push entonces la sube a dicho repositorio.

Bien sigamos con nuestro ejemplo, localizamos nuestro terminal en la carpeta de nuestro ejemplo y correremos este primer comando

docker build --rm -f "Dockerfile" -t hello:v1 .

En esta instrucción le decimos a nuestro -f indicando el nombre del archivo en este y casi todos los casos Dockerfile, –rm que remueva contenedores intermedios una vez terminada la ejecución, -t nombre y tag de la aplicación en nuestro caso nombre hello y tag v1 y un punto final que indica el directorio.

Vemos como comienza a crear nuestra imagen y a seguir los pasos que indicamos en nuestro archivo docker. Pues bien felicidades primer imagen de docker creada. para verla solo corremos el comando

docker image ls

Ahora vamos a verlo en ejecución, para esto ahora ejecutaremos el siguiente comando

docker run --rm -d -p 8081:80/tcp hello:v1

esto nos generará un hash de compilación, ahora vamos a nuestro navegador y escriba locallhost:8081

Buenísimo ya esta nuestra primer aplicación corriendo con Docker, mmmm y ahora como la detengo, bueno ahora vamos a correr dos instrucciones más

docker container ls

Este comando nos mostrara nuestros contenedores desplegados, su ID, el nombre de la imagen que está corriendo, hace cuanto se creo y su forwarding de salida. Bien copiemos su ID y corramos este segundo comando.

docker container stop [Container-ID]

Y listo hemos detenido este contenedor y ya no está ejecutándose, así de fácil es desplegar un ambiente, solo con lo que necesitamos y ver nuestra aplicación corriendo en el y tan sencillo como la desplegamos la podemos detener.