Docker Compose Starter Guide

El autor del artículo, cuya traducción publicamos hoy, dice que está destinado a aquellos desarrolladores que desean aprender Docker Compose y van a crear su primera aplicación cliente-servidor con Docker. Se supone que el lector debe estar familiarizado con los conceptos básicos de Docker. Si este no es el caso, puede echar un vistazo a esta serie de materiales, esta publicación, donde se discuten los conceptos básicos de Docker junto con los conceptos básicos de Kubernetes, y este artículo para principiantes.

¿Qué es Docker Compose?

Docker Compose es una herramienta incluida con Docker. Está diseñado para resolver los problemas asociados con el despliegue de proyectos.

Al estudiar los conceptos básicos de Docker, puede encontrar la creación de aplicaciones simples que funcionan de manera autónoma, independiente de, por ejemplo, fuentes de datos externas o ciertos servicios. En la práctica, tales aplicaciones son raras. Los proyectos reales generalmente incluyen un conjunto completo de aplicaciones colaborativas.

¿Cómo sabe si necesita usar Docker Compose al implementar un proyecto? De hecho, muy simple. Si se utilizan varios servicios para garantizar el funcionamiento de este proyecto, Docker Compose puede ser útil. Por ejemplo, en una situación en la que crean un sitio web que, para autenticar a los usuarios, necesita conectarse a la base de datos. Un proyecto similar puede constar de dos servicios: uno que proporciona el sitio y otro responsable de mantener la base de datos.

La tecnología Docker Compose, si se describe de manera simplificada, permite, con un solo comando, lanzar muchos servicios.

Diferencia entre Docker y Docker Compose

Docker se usa para administrar los contenedores individuales (servicios) que componen la aplicación.

Docker Compose se usa para administrar simultáneamente múltiples contenedores que componen la aplicación. Esta herramienta ofrece las mismas características que Docker, pero le permite trabajar con aplicaciones más complejas.


Docker (contenedor único) y Docker Compose (contenedores múltiples)

Caso de uso típico de Docker Compose

Docker Compose es, en las manos adecuadas, una herramienta muy poderosa que le permite implementar rápidamente aplicaciones con una arquitectura compleja. Ahora veremos un ejemplo del uso práctico de Docker Compose, cuyo análisis le permitirá evaluar las ventajas que le dará el uso de Docker Compose.

Imagina que eres un desarrollador de un proyecto web. Este proyecto incluye dos sitios web. El primero permite a las personas en los negocios crear, con solo unos pocos clics, tiendas en línea. El segundo está dirigido a la atención al cliente. Estos dos sitios interactúan con la misma base de datos.

Su proyecto se está volviendo más popular y resulta que la potencia del servidor en el que funciona ya no es suficiente. Como resultado, decide transferir todo el proyecto a otra máquina.

Desafortunadamente, no usaste algo como Docker Compose. Por lo tanto, tendrá que transferir y reconfigurar los servicios uno por uno, con la esperanza de que, en el proceso de este trabajo, no olvide nada.

Si usa Docker Compose, transferir su proyecto a un nuevo servidor es un asunto que puede resolverse ejecutando varios comandos. Para completar la transferencia del proyecto a un nuevo lugar, solo necesita realizar algunas configuraciones y cargar una copia de seguridad de la base de datos en el nuevo servidor.

Desarrollar una aplicación cliente-servidor usando Docker Compose

Ahora que sabe para qué vamos a utilizar Docker Compose, es hora de crear su primera aplicación cliente-servidor con esta herramienta. Es decir, estamos hablando del desarrollo de un pequeño sitio web (servidor) en Python, que puede producir un archivo con un fragmento de texto. Este archivo es solicitado al servidor por un programa (cliente), también escrito en Python. Después de recibir el archivo del servidor, el programa muestra el texto almacenado en la pantalla.

Tenga en cuenta que esperamos que posea los conceptos básicos de Docker y que ya tenga instalada la plataforma Docker.

Vamos a trabajar en el proyecto.

▍1. Creación de proyectos

Para construir su primera aplicación cliente-servidor, sugiero comenzar con la creación de una carpeta de proyecto. Debe contener los siguientes archivos y carpetas:

• docker-compose.yml . Este es un archivo Docker Compose que contendrá las instrucciones necesarias para iniciar y configurar los servicios.
• Carpeta del server Contendrá los archivos necesarios para garantizar el funcionamiento del servidor.
• Carpeta client . Aquí estarán los archivos de la aplicación cliente.

Como resultado, el contenido de la carpeta principal de su proyecto debería verse así:

 . ├── client/ ├── docker-compose.yml └── server/ 2 directories, 1 file 

▍2. Creación del servidor

Aquí, en el proceso de creación del servidor, tocaremos algunas cosas básicas relacionadas con Docker.

2a. Creación de archivos

Vaya a la carpeta del server y cree los siguientes archivos en ella:

• server.py archivo. Contendrá el código del servidor.
• Archivo index.html . Este archivo contendrá un texto que la aplicación del cliente debe mostrar.
• Archivo Dockerfile . Este es un archivo Docker que contendrá las instrucciones necesarias para crear un entorno de servidor.

Así debería verse el contenido de su server/ carpeta:

 . ├── Dockerfile ├── index.html └── server.py 0 directories, 3 files 

2b. Edición de un archivo Python.

Agregue el siguiente código al archivo server.py :

 #!/usr/bin/env python3 #    python. #       -. #     - ,      Python. import http.server import socketserver #         . handler = http.server.SimpleHTTPRequestHandler #   ,        1234. #    ,        ,    docker-compose. with socketserver.TCPServer(("", 1234), handler) as httpd:   #       ,    .  httpd.serve_forever() 

Este código le permite crear un servidor web simple. Dará a los clientes el archivo index.html , cuyo contenido se mostrará más tarde en la página web.

2c. Edición de archivos HTML

Agregue el siguiente texto al archivo index.html :

 Docker-Compose is magic! 

Este texto será transmitido al cliente.

2d. Edición de Dockerfile

Ahora crearemos un Dockerfile simple, que será responsable de organizar el tiempo de ejecución para el servidor Python. Utilizaremos la imagen oficial destinada a la ejecución de programas escritos en Python como base de la imagen creada. Aquí están los contenidos del Dockerfile:

 #    ,  Dockerfile       . #      'FROM'. #      python ( DockerHub). #   ,    ,  'python',     - 'latest'. FROM python:latest #       ,   Python,     'server.py'  'index.html'. #     ,     'ADD'. #  , 'server.py',    ,   . #  , '/server/',  ,        . #        '/server/'. ADD server.py /server/ ADD index.html /server/ #     'WORKDIR', ,   . #      . #    ,      ,   '/server/'. WORKDIR /server/ 

Ahora trabajemos en el cliente.

▍3. Creación de clientes

Al crear la parte del cliente de nuestro proyecto, recordaremos simultáneamente algunos de los conceptos básicos de Docker.

3a. Creación de archivos

Vaya a la carpeta de su proyecto de client y cree los siguientes archivos:

• El archivo client.py . Este será el código del cliente.
• Archivo Dockerfile . Este archivo juega el mismo papel que un archivo similar en la carpeta del servidor. A saber, contiene instrucciones que describen la creación de un entorno para ejecutar código de cliente.

Como resultado, su client/ carpeta en esta etapa del trabajo debería verse así:

 . ├── client.py └── Dockerfile 0 directories, 2 files 

3b. Edición de archivos Python

Agregue el siguiente código al archivo client.py :

 #!/usr/bin/env python3 #    Python. #      'index.html'  . #     ,      Python. import urllib.request #      'http://localhost:1234/'. # ,      ,   'http://localhost:1234'. # localhost   ,      . # 1234 -   ,        . fp = urllib.request.urlopen("http://localhost:1234/") # 'encodedContent'     ('index.html'). # 'decodedContent'     (  ,      ). encodedContent = fp.read() decodedContent = encodedContent.decode("utf8") #   ,    ('index.html'). print(decodedContent) #    . fp.close() 

Gracias a este código, la aplicación cliente puede descargar datos del servidor y mostrarlos en la pantalla.

3c. Edición de Dockerfile

Como en el caso del servidor, creamos un Dockerfile simple para el cliente, responsable de crear el entorno en el que funcionará la aplicación Python del cliente. Aquí está el código del Dockerfile del cliente:

 #   ,     Dockerfile. FROM python:latest #  'client.py'   '/client/'. ADD client.py /client/ #      '/client/'. WORKDIR /client/ 

▍4. Docker componer

Como habrás notado, creamos dos proyectos diferentes: el servidor y el cliente. Cada uno de ellos tiene su propio Dockerfile . Hasta ahora, todo lo que sucede no va más allá de lo básico de trabajar con Docker. Ahora estamos comenzando con Docker Compose. Para hacer esto, recurrimos al archivo docker-compose.yml ubicado en la carpeta raíz del proyecto.

Tenga en cuenta que aquí no estamos tratando de considerar absolutamente todos los comandos que se pueden usar en docker-compose.yml . Nuestro objetivo principal es brindarle un ejemplo práctico que le brinde conocimientos básicos de Docker Compose.

Aquí está el código para poner en el docker-compose.yml :

 #  docker-compose     . #   "3"    -        . version: "3" #  ,  docker-composes   . # 1  = 1 . #    , ,   ... # ,     ,   'services'. services: #    ,       . #  ,     . #   (): . #    ,   . #       . #  ,    ,    'server'. server:   #   "build"     #    Dockerfile,      ,   #    .   #  'server/'     ,   #    Dockerfile.   build: server/   # ,      .   #     "python ./server.py".   command: python ./server.py   #   ,      'server/server.py'   1234.   #          (   ),   #         .   #       'ports'.   #      : [ ]:[ ]   #        1234         # 1234  (         #   ).   ports:     - 1234:1234 #   (): . #    'client'. client:   #  'client/    ,     #  Dockerfile    .   build: client/   # ,      .   #     "python ./client.py".   command: python ./client.py   #   'network_mode'     .   #    ,      'localhost' .   network_mode: host   #   'depends_on'  ,   ,   #   , ,       .   #  ,   'client'       'server'.   depends_on:     - server 

▍5. Asamblea de proyecto

Después de incluir todas las instrucciones necesarias en docker-compose.yml , el proyecto debe ser ensamblado. Este paso de nuestro trabajo se asemeja al uso del docker build , pero el comando correspondiente está relacionado con varios servicios:

 $ docker-compose build 

▍6. Lanzamiento del proyecto

Ahora que el proyecto está completo, es hora de lanzarlo. Este paso de nuestro trabajo corresponde al paso en el cual, cuando se trabaja con contenedores individuales, se docker run comando docker run :

 $ docker-compose up 

Después de ejecutar este comando, el terminal debería mostrar el texto descargado por el cliente del servidor: ¡ Docker-Compose is magic! .

Como ya se mencionó, el servidor usa el puerto 1234 la computadora para atender las solicitudes de los clientes. Por lo tanto, si va al navegador en http: // localhost: 1234 / , se mostrará una página con el texto Docker-Compose is magic! .

Comandos útiles

Veamos algunos de los comandos que pueden resultarle útiles al trabajar con Docker Compose.

Este comando le permite detener y eliminar contenedores y otros recursos creados por el docker-compose up :

 $ docker-compose down 

Este comando muestra los registros de servicio:

 $ docker-compose logs -f [service name] 

Por ejemplo, en nuestro proyecto se puede usar de la siguiente forma: $ docker-compose logs -f [service name] .

Con este comando, puede enumerar los contenedores:

 $ docker-compose ps 

Este comando le permite ejecutar un comando en un contenedor de ejecución:

 $ docker-compose exec [service name] [command] 

Por ejemplo, podría verse así: docker-compose exec server ls .

Este comando le permite mostrar una lista de imágenes:

 $ docker-compose images 

Resumen

Examinamos los conceptos básicos de trabajar con la tecnología Docker Compose, cuyo conocimiento le permitirá utilizar esta tecnología y, si lo desea, comenzar un estudio más profundo. Aquí está el repositorio con el código del proyecto que revisamos aquí.

Estimados lectores! ¿Usas Docker Compose en tus proyectos?