Cómo compilar y ejecutar sus aplicaciones usando Docker Compose

Docker compose, anteriormente conocido como Fig, es una herramienta que puede definir y ejecutar aplicaciones complejas usando Docker. Básicamente hace el trabajo de crear múltiples contenedores y enlaces entre ellos.

El uso de Docker Compose requiere definir el entorno requerido para su aplicación usando un Dockerfile y los servicios requeridos para la aplicación en un archivo ‘.yml’. Luego, se puede usar un solo comando para crear e iniciar todos los servicios desde el archivo de configuración. En este artículo, aprenderemos cómo instalar y usar compose en Ubuntu 15.10. También hablaremos sobre cómo ejecutar su aplicación usándola.

Instalación

El requisito previo para instalar Docker Compose es Docker Engine. Si aún no ha instalado Docker Engine, estos son los pasos rápidos para el mismo:

$ sudo apt-get update

$ sudo apt-get install linux-image-extra-$(uname -r)

$ sudo apt-get install docker-engine

Para verificar si la instalación de Docker fue exitosa, ejecutemos un programa hello-world:

$sudo docker run hello-world

poornima@BNPTHKPD:~$ sudo docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
03f4658f8b78: Pull complete
a3ed95caeb02: Pull complete
Digest: sha256:8be990ef2aeb16dbcb9271ddfe2610fa6658d13f6dfb8bc72074cc1ca36966a7
Status: Downloaded newer image for hello-world:latest

Hello from Docker.
This message shows that your installation appears to be working correctly.

.......

Ahora para instalar Compose, ejecute el siguiente comando curl en la terminal:

$ curl -L https://github.com/docker/compose/releases/download/1.7.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

Establecer permisos ejecutables para el binario

$ chmod +x /usr/local/bin/docker-compose

Verifique si la instalación está completa:

$docker compose --version

root@BNPTHKPD:/home/poornima# docker-compose --version
docker-compose version 1.7.0, build 0d7bf73

Comandos de composición de Docker

Antes de continuar y aprender a ejecutar sus aplicaciones usando Compose, permítame presentarle algunos de sus comandos importantes.

La sintaxis del comando docker-compose es

docker-compose [-f=...] [options] [commands] [args]

Uno puede verificar la versión de docker-compose usando:

docker-compose  -v, --version

Cuando se usa con el comando ‘ps’, enumera los contenedores disponibles

docker-compose ps

Puede crear e iniciar sus contenedores usando el comando ‘up’ y agregar la opción ‘-d’ ejecutará los contenedores en segundo plano

docker-compose up -d

A continuación se enumeran algunos comandos más que se pueden usar con docker-compose:

build -  to build services

pause / unpause  -  pause and unpause services

stop -  stop services

restart - restart services

rm  - remove stopped containers

logs - view output from containers

help - to get help on a command

Construyendo y ejecutando su aplicación

En esta sección, nos centraremos en crear una aplicación web Python simple y ejecutarla con Docker Compose.

Configuración

Primero creemos un directorio para nuestra aplicación.

poornima@BNPTHKPD:~$ mkdir dockcompose
poornima@BNPTHKPD:~$ cd dockcompose/

Ahora crearemos una aplicación web Hello World myapp.py usando el marco Flask en este directorio con el siguiente contenido:

from flask import Flask

app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello World using Docker Compose'

if __name__ == '__main__':
app.run(debug=True,host="0.0.0.0")

Cree un archivo requirements.txt en el mismo directorio del proyecto que contenga lo siguiente:

Flask==0.10.1

En el siguiente paso, necesitamos crear una imagen de Docker que contenga todas las dependencias que necesita la aplicación Python.

Crear una imagen de Docker

Para esto, cree un archivo llamado Dockerfile nuevamente en el directorio del proyecto con el siguiente contenido:

FROM python:2.7

ADD . /code

WORKDIR /code

RUN pip install -r requirements.txt

CMD python myapp.py

Este archivo le informa a Docker que cree una imagen usando Python 2.7, agregue el directorio ‘.’ en la ruta ‘/ code’ en la imagen, establezca el directorio de trabajo en / code, instale las dependencias de Python como se menciona en el archivo requirements.txt y establezca el comando predeterminado del contenedor en ‘python myapp.py’

Ahora construiremos la imagen.

$ docker build -t web .

poornima@BNPTHKPD:~/dockcompose$ sudo docker build -t web .
Sending build context to Docker daemon 5.632 kB
Step 1 : FROM python:2.7
---> a3b29970a425
Step 2 : ADD . /code
---> 855e1a126850
Removing intermediate container 2e713165c053
Step 3 : WORKDIR /code
---> Running in 431e3f52f421
---> 157b4cffd6df
Removing intermediate container 431e3f52f421
Step 4 : RUN pip install -r requirements.txt
---> Running in 07c294591a76
Collecting Flask==0.10.1 (from -r requirements.txt (line 1))
Downloading Flask-0.10.1.tar.gz (544kB)
Collecting Werkzeug>=0.7 (from Flask==0.10.1->-r requirements.txt (line 1))
Downloading Werkzeug-0.11.8-py2.py3-none-any.whl (306kB)
Collecting Jinja2>=2.4 (from Flask==0.10.1->-r requirements.txt (line 1))
Downloading Jinja2-2.8-py2.py3-none-any.whl (263kB)
Collecting itsdangerous>=0.21 (from Flask==0.10.1->-r requirements.txt (line 1))
Downloading itsdangerous-0.24.tar.gz (46kB)
Collecting MarkupSafe (from Jinja2>=2.4->Flask==0.10.1->-r requirements.txt (line 1))
Downloading MarkupSafe-0.23.tar.gz
Building wheels for collected packages: Flask, itsdangerous, MarkupSafe
Running setup.py bdist_wheel for Flask: started
Running setup.py bdist_wheel for Flask: finished with status 'done'
Stored in directory: /root/.cache/pip/wheels/d2/db/61/cb9b80526b8f3ba89248ec0a29d6da1bb6013681c930fca987
Running setup.py bdist_wheel for itsdangerous: started
Running setup.py bdist_wheel for itsdangerous: finished with status 'done'
Stored in directory: /root/.cache/pip/wheels/97/c0/b8/b37c320ff57e15f993ba0ac98013eee778920b4a7b3ebae3cf
Running setup.py bdist_wheel for MarkupSafe: started
Running setup.py bdist_wheel for MarkupSafe: finished with status 'done'
Stored in directory: /root/.cache/pip/wheels/94/a7/79/f79a998b64c1281cb99fa9bbd33cfc9b8b5775f438218d17a7
Successfully built Flask itsdangerous MarkupSafe
Installing collected packages: Werkzeug, MarkupSafe, Jinja2, itsdangerous, Flask
Successfully installed Flask-0.10.1 Jinja2-2.8 MarkupSafe-0.23 Werkzeug-0.11.8 itsdangerous-0.24
---> 9ef07d3ed698
Removing intermediate container 07c294591a76
Step 5 : CMD python myapp.py
---> Running in ac5ce91ddc85
---> 65d218cbea14
Removing intermediate container ac5ce91ddc85
Successfully built 65d218cbea14
poornima@BNPTHKPD:~/dockcompose$ sudo docker-compose up
Starting dockcompose_web_1
Attaching to dockcompose_web_1
web_1 | * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
web_1 | * Restarting with stat
web_1 | * Debugger is active!
web_1 | * Debugger pin code: 151-559-328
web_1 | 172.17.0.1 - - [19/Apr/2016 08:17:43] "GET / HTTP/1.1" 200 -
web_1 | 172.17.0.1 - - [19/Apr/2016 08:17:43] "GET /favicon.ico HTTP/1.1" 404 -

Este comando puede ubicar automáticamente los archivos Dockerfile, requirements.txt y myapp.py requeridos y construye la imagen ‘web’ usándolos.

Archivos de servicios

Los diferentes servicios que se utilizarán en su aplicación deben reunirse en un archivo llamado docker-compose.yml. El archivo de servicio para nuestra aplicación Python HelloWorld tiene el siguiente aspecto:

web:
build: .
ports:
- "5000:5000"

El archivo anterior define el servicio web que se construye a partir del directorio actual y reenvía el puerto 5000 expuesto del contenedor al puerto 5000 en el host.

Ejecutando la aplicación

Ahora vayamos al directorio del proyecto y ejecutemos la aplicación:

$docker-compose up

Para ver la aplicación en ejecución, apunte su navegador web a lo siguiente:

http://0.0.0.0:5000

Así es como su navegador le muestra el mensaje:

Más comandos

Probemos algunos comandos para ver cómo funcionan.

Nota: Todos los comandos de docker compose deben ejecutarse desde el directorio que contiene docker-compose.yml

Para ejecutar sus servicios en segundo plano, use la opción ‘-d’.

poornima@BNPTHKPD:~/dockcompose$ sudo docker-compose up -d
Starting dockcompose_web_1

Para listar todos los contenedores, use la opción ‘ps’.

poornima@BNPTHKPD:~/dockcompose$ sudo docker-compose ps
Name Command State Ports
-------------------------------------------------------------------------
dockcompose_web_ /bin/sh -c Up 0.0.0.0:5000->50
1 python myapp.py 00/tcp

Para ver las variables de entorno disponibles en el servicio configurado (en este caso, web), use la opción ‘env’.

poornima@BNPTHKPD:~/dockcompose$ sudo docker-compose run web env
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=d5c2b9eeab7f
TERM=xterm
WEB_PORT=tcp://172.17.0.2:5000
WEB_PORT_5000_TCP=tcp://172.17.0.2:5000
WEB_PORT_5000_TCP_ADDR=172.17.0.2
WEB_PORT_5000_TCP_PORT=5000
WEB_PORT_5000_TCP_PROTO=tcp
WEB_NAME=/dockcompose_web_run_1/web
WEB_ENV_LANG=C.UTF-8
WEB_ENV_GPG_KEY=C01E1CAD5EA2C4F0B8E3571504C367C218ADD4FF
WEB_ENV_PYTHON_VERSION=2.7.11
WEB_ENV_PYTHON_PIP_VERSION=8.1.1
WEB_1_PORT=tcp://172.17.0.2:5000
WEB_1_PORT_5000_TCP=tcp://172.17.0.2:5000
WEB_1_PORT_5000_TCP_ADDR=172.17.0.2
WEB_1_PORT_5000_TCP_PORT=5000
WEB_1_PORT_5000_TCP_PROTO=tcp
WEB_1_NAME=/dockcompose_web_run_1/web_1
WEB_1_ENV_LANG=C.UTF-8
WEB_1_ENV_GPG_KEY=C01E1CAD5EA2C4F0B8E3571504C367C218ADD4FF
WEB_1_ENV_PYTHON_VERSION=2.7.11
WEB_1_ENV_PYTHON_PIP_VERSION=8.1.1
DOCKCOMPOSE_WEB_1_PORT=tcp://172.17.0.2:5000
DOCKCOMPOSE_WEB_1_PORT_5000_TCP=tcp://172.17.0.2:5000
DOCKCOMPOSE_WEB_1_PORT_5000_TCP_ADDR=172.17.0.2
DOCKCOMPOSE_WEB_1_PORT_5000_TCP_PORT=5000
DOCKCOMPOSE_WEB_1_PORT_5000_TCP_PROTO=tcp
DOCKCOMPOSE_WEB_1_NAME=/dockcompose_web_run_1/dockcompose_web_1
DOCKCOMPOSE_WEB_1_ENV_LANG=C.UTF-8
DOCKCOMPOSE_WEB_1_ENV_GPG_KEY=C01E1CAD5EA2C4F0B8E3571504C367C218ADD4FF
DOCKCOMPOSE_WEB_1_ENV_PYTHON_VERSION=2.7.11
DOCKCOMPOSE_WEB_1_ENV_PYTHON_PIP_VERSION=8.1.1
LANG=C.UTF-8
GPG_KEY=C01E1CAD5EA2C4F0B8E3571504C367C218ADD4FF
PYTHON_VERSION=2.7.11
PYTHON_PIP_VERSION=8.1.1
HOME=/root

Para detener contenedores, use la opción ‘detener’:

poornima@BNPTHKPD:~/dockcompose$ sudo docker-compose stop
Stopping dockcompose_web_1 ... done

Puede pausarlos y reanudarlos usando la opción ‘pausar’ y ‘reanudar la pausa’.

poornima@BNPTHKPD:~/dockcompose$ sudo docker-compose pause
Pausing dockcompose_web_1 ... done

poornima@BNPTHKPD:~/dockcompose$ sudo docker-compose ps
Name Command State Ports
-------------------------------------------------------------------------
dockcompose_web_ /bin/sh -c Paused 0.0.0.0:5000->50
1 python myapp.py 00/tcp

poornima@BNPTHKPD:~/dockcompose$ sudo docker-compose unpause
Unpausing dockcompose_web_1 ... done

Utilice el comando ‘matar’ para detener todos los contenedores de una vez.

$ sudo docker-compose kill

Los registros de redacción se pueden revisar mediante el comando ‘log’.

$ sudo docker-compose logs

Si necesita ayuda para enumerar todos los comandos / opciones disponibles, use el comando de ayuda.

poornima@BNPTHKPD:~/dockcompose$ sudo docker-compose --help
Define and run multi-container applications with Docker.

Usage:
docker-compose [-f=...] [options] [COMMAND] [ARGS...]
docker-compose -h|--help

Options:
-f, --file FILE Specify an alternate compose file (default: docker-compose.yml)
-p, --project-name NAME Specify an alternate project name (default: directory name)
--verbose Show more output
-v, --version Print version and exit
-H, --host HOST Daemon socket to connect to

--tls Use TLS; implied by --tlsverify
--tlscacert CA_PATH Trust certs signed only by this CA
--tlscert CLIENT_CERT_PATH Path to TLS certificate file
--tlskey TLS_KEY_PATH Path to TLS key file
--tlsverify Use TLS and verify the remote
--skip-hostname-check Don't check the daemon's hostname against the name specified
in the client certificate (for example if your docker host
is an IP address)

Commands:
build Build or rebuild services
config Validate and view the compose file
create Create services
down Stop and remove containers, networks, images, and volumes
events Receive real time events from containers
exec Execute a command in a running container
help Get help on a command
kill Kill containers
logs View output from containers
pause Pause services
port Print the public port for a port binding
ps List containers
pull Pulls service images
restart Restart services
rm Remove stopped containers
run Run a one-off command
scale Set number of containers for a service
start Start services
stop Stop services
unpause Unpause services
up Create and start containers
version Show the Docker-Compose version information

Conclusión

Docker Compose es una herramienta maravillosa para crear fácilmente una aplicación escalable y rica en funciones. Con sus capacidades y simplicidad, es bastante útil como herramienta de desarrollo. Para obtener más información sobre la herramienta y la creación de aplicaciones, visite su Página Oficial