() translation by (you can also view the original English article)
A las personas que hacen Docker les gusta describirlo usando una metáfora de una pieza de tecnología bastante antigua: el contenedor de envío.
Si bien ni siquiera pensamos en ellos o los notamos mucho ahora, el contenedor de envío fue en realidad una pieza de tecnología bastante revolucionaria en su tiempo. No importa qué forma o tamaño era el artículo original, mediante el uso de un contenedor estandarizado, el propietario del barco / avión / camión / lo que-tiene-usted, fue capaz de averiguar fácilmente cuántos recursos que necesitaban asignar.
Docker intenta tomar este mismo nivel de comodidad y llevarlo al mundo del servidor. Es la extensión natural de herramientas como Vagrant que le permiten implementar la misma máquina virtual que usa en el desarrollo en entornos de producción. Las máquinas virtuales de estilo vagabundo son geniales, pero son de peso pesado. Necesitan muchos recursos para ejecutarse, muchos de los cuales son redundantes: una imagen vagrant carga una copia nueva completa de Linux dentro de una existente. ¿No sería mejor si pudiera usar la conveniencia y uniformidad de Vagrant pero no tuviera que volver a cargar todo el sistema operativo? Bueno, eso es exactamente lo que hace Docker.
Introducción
En este tutorial, le guiaré por todo el flujo de trabajo de Docker.In this tutorial, I'll walk you through the entire Docker workflow. Primero seguiremos los pasos para obtener una aplicación web de Python simple que tiene un par de dependencias de Python y depende de una base de datos de Redis para la persistencia en funcionamiento. A continuación, instalaremos Docker e instalaremos todos los requisitos de la aplicación web (dependencias de Redis, Python y Python) en una imagen de Docker.Then we'll install Docker and install all the web app's requirements (Redis, Python, and Python's dependencies) into one Docker image. A continuación, usaremos esa imagen y la implementaremos en un servidor diferente.
Solo implementaremos una aplicación de ejemplo de juegos, pero los pasos para implementar sus propias aplicaciones reales serían muy similares.
Para comenzar, necesitará una caja de Linux que ejecute una versión reciente de Ubuntu o una máquina virtual que ejecute una versión reciente de Ubuntu. Si desea seguir completamente el tutorial e implementar la aplicación, también necesitará una segunda máquina (o segunda máquina virtual) para implementar.
Instalación de Docker
El primer paso es instalar Docker en sí. Docker está en desarrollo muy rápido, por lo que la forma más fácil de instalarlo a menudo cambia con bastante rapidez. Echa un vistazo a la sección de introducción de Docker si quieres ver la vanguardia.
De lo contrario, siga los pasos a continuación y configuraremos una instalación basada en máquina virtual Vagrant de Docker que funcionará en cualquiera de los principales sistemas operativos. Primero dirígete al sitio web de Vagrant e instala lo último en Vagrant y VirtualBox para tu sistema operativo.
Una vez instalado Vagrant, cree una nueva carpeta, abra un símbolo del sistema allí y haga lo siguiente:
1 |
vagrant init hashicorp/precise64 |
2 |
(... wait a while ...) |
3 |
vagrant up |
4 |
vagrant ssh |
Vagrant solo se encargó de crear una máquina virtual que ejecuta Ubuntu 12.04 para usted y ahora está SSH'd en su solicitud. Ahora podemos seguir las instrucciones de instalación de Ubuntu de Docker. Consulte el sitio web en caso de que haya habido algún cambio desde que se escribió esto, pero lo más probable es que pueda pegar directamente los siguientes comandos en el terminal:
1 |
# install the backported kernel
|
2 |
sudo apt-get update
|
3 |
sudo apt-get install linux-image-generic-lts-raring linux-headers-generic-lts-raring |
4 |
|
5 |
# reboot
|
6 |
sudo reboot
|
Volverá al símbolo del sistema de su máquina local cuando se reinicie la máquina virtual, así que espere unos momentos y haga otro:
1 |
vagrant ssh |
... a SSH de nuevo en la máquina virtual. Ahora que los requisitos previos de Docker se han instalado correctamente, tenemos que seguir adelante e instalar Docker en sí. Pegue el siguiente comando:
1 |
curl -s https://get.docker.io/ubuntu/ | sudo sh |
... que tomará un script de instalación de Docker simple del sitio de Docker y lo ejecutará. Docker ahora debe instalarse correctamente, así que comencemos a jugar con él.
Introducción a Docker
Una vez que apt-get haya terminado su magia, haga lo siguiente:
1 |
sudo Docker run -i -t ubuntu /bin/bash |
... para comprobar y ver que la instalación se realizó correctamente. Si funciona, Docker procederá a descargar una imagen de Ubuntu Docker y después de algún tiempo, terminará en lo que parece un símbolo del sistema de raíz. Siéntase libre de jugar un poco, notará que está en un entorno que está completamente separado de su máquina host. Probablemente haya notado el inicio de sesión raíz y # en el símbolo del sistema. Se está ejecutando como usuario root en un nuevo entorno virtual. Si emite un comando users, verá que los demás usuarios ya no están presentes.
Vale la pena tomarse un minuto para explicar lo que hizo el comando docker que acaba de escribir y cómo sucedió esta magia.
El comando run
La utilidad Docker parece haber tomado mucha inspiración de la interfaz de línea de comandos de git y, como resultado, hace uso de subcomandos. En este caso, ejecutamos el subcomando run. El comando run requiere dos argumentos: una imagen y un comando.
También es inteligente, por lo que si (como en este caso) no tiene esa imagen instalada, consultará el repositorio central de Docker y descargará uno por usted. Aquí le dijimos que ejecutara una imagen de ubuntu e informamos a Docker que debería iniciar /bin/bash dentro de esa imagen. -t y -i le dicen a Docker que asigne un TTY y se ejecute en "modo interactivo", en otras palabras, para obtener un símbolo del sistema. La razón de esto es que Docker funciona de manera un poco diferente a otro software de virtualización con el que podría estar familiarizado. Las imágenes de Docker no "arrancan", simplemente se ejecutan. Están usando la instalación de Linux existente, por lo que iniciar una imagen de Docker puede ser inmediato. De alguna manera, Docker está más cerca del comando chroot de Linux que de las herramientas de virtualización más tradicionales como VMWare o VirtualBox.
Hay algunas otras diferencias clave con respecto a las herramientas de virtualización estándar. Vamos a hacer un experimento rápido y crear un archivo e imprimir el contenido del mismo:
1 |
echo An experiment > experiment.txt |
Ahora, cuando lo haces:
1 |
cat experiment.txt
|
Con mucho gusto imprimirá:
1 |
An experiment |
Hasta aquí todo bien, nuestro experimento tonto está funcionando exactamente como se esperaba. Salgamos de Docker y volvamos al símbolo del sistema de nuestra máquina host:
1 |
exit
|
Si reinicia Docker con el mismo comando que usó antes:
1 |
sudo Docker run -i -t ubuntu /bin/bash |
... notarás que las cosas ya no se comportan de la manera que esperarías. Si intenta cat el archivo que creamos la última vez, ahora obtendrá un mensaje de error:
1 |
root@e97acdf4160c:/# cat experiment.txt
|
2 |
cat: experiment.txt: No such file or directory
|
Entonces, ¿qué está pasando? Los cambios en las imágenes de Docker no se conservan de forma predeterminada. Para guardar los cambios en una imagen de Docker, debe confirmarlos, estilo git. Esto puede tomar un poco de acostumbrarse, pero es bastante poderoso porque significa que también puede "ramificarlos" estilo git (más sobre eso más adelante).
Guardar nuevas imágenes
Por ahora, hagamos algo un poco más útil. Vamos a instalar Python, redis y algunas otras utilidades que usaremos para ejecutar nuestra aplicación de demostración en breve. Después, nos comprometeremos a persistir nuestros cambios. Inicie una copia de Docker en la última imagen de Ubuntu:
1 |
docker -t -i ubuntu /bin/bash |
La imagen base de Ubuntu puede no incluir Python, así que verifique si tiene una copia escribiendo python en el símbolo del sistema. Si recibe un mensaje de error, vamos a instalarlo:
1 |
apt-get update |
2 |
apt-get install python
|
Hasta ahora, bien. Es posible que más adelante queramos hacer otros proyectos que hagan uso de Python, así que sigamos adelante y guardemos estos cambios. Abra otro símbolo del sistema (si está utilizando la instalación de Vagrant recomendada anteriormente, tendrá que volver a vagrant ssh desde un símbolo del sistema separado) y haga lo siguiente:
1 |
docker ps |
Obtendrá una lista como la siguiente, de todos los contenedores de Docker que se están ejecutando actualmente:
1 |
ID IMAGE COMMAND CREATED STATUS PORTS |
2 |
54a11224dae6 ubuntu:12.04 /bin/bash 6 minutes ago Up 6 minutes |
El número bajo la columna ID es importante: este es el ID de su contenedor. Estos son únicos, si sale de su contenedor y ejecuta la misma imagen de nuevo, verá un nuevo número allí.
Así que ahora que tenemos Python instalado, vamos a guardar nuestros cambios. Para ello se utiliza el comando commit que toma dos argumentos: el contenedor cuyos cambios se desea almacenar y el nombre de la imagen. La convención de Docker es usar un id de usuario seguido de un / y el nombre corto de la imagen. Así que en este caso, llamémoslo tuts / python. Emita el siguiente comando para guardar la instalación de Python, asegurándose de sustituir el ID de su contenedor desde el último paso
1 |
docker commit tuts/python |
Después de unos segundos, volverá con una serie de letras y números. Este es el ID de la imagen que acaba de guardar. Puede ejecutar esta imagen cuando lo desee y hacer referencia a ella ya sea por este número de identificación o por el nombre de tuts / python más fácil de recordar que le asignamos.
Vamos a ejecutar una copia de la imagen que acabamos de hacer:
1 |
docker run -t -i tuts/python /bin/bash |
En este punto, debe tener dos ventanas de terminal abiertas que ejecuten dos sesiones de Docker independientes.
Ahora notará que si escribe python en cualquiera de ellos, ya no recibirá un mensaje de error. Intente crear un archivo en la segunda ventana:
1 |
touch /testfile
|
Ahora vuelva a la ventana original de Docker e intente ver el archivo:
1 |
cat /testfile
|
Recibirá un mensaje de error. Esto se debe a que está ejecutando una "máquina virtual" completamente diferente basada en la imagen que creó con el comando docker commit. Los sistemas de archivos son completamente independientes.
Si abres otro terminal (de nuevo, tendrás que ejecutar vagrant ssh si usas Vagrant) y hacer lo siguiente:
1 |
docker ps |
... verá que docker ahora enumera dos imágenes en ejecución, no solo una. Puede comprometerse por separado con cada una de esas imágenes. Para continuar con la metáfora git, ahora estás trabajando con dos ramas y son libres de "divergir".
Sigamos adelante y cerremos la última ventana que abrimos. Si vuelve a ejecutar docker ps, ahora solo aparecerá un identificador. Pero, ¿qué pasa si desea volver a un contenedor anterior? Si escribe:
1 |
docker ps -a
|
Docker también enumerará todos los contenedores anteriores. No puede ejecutar un contenedor que haya salido, pero puede usar los IDs del contenedor anterior para confirmar nuevas imágenes. La ejecución de la nueva imagen le llevará efectivamente al estado de su contenedor anterior.
Vamos a cerrar las nuevas ventanas que abrimos y volver al terminal para la primera sesión de Docker que iniciamos. Una vez de vuelta, sigue adelante e instala algunas herramientas más para nuestra pequeña aplicación. En este caso, necesitamos instalar el administrador de paquetes de Python, dos módulos de Python para permitir que Python actúe como un servidor web e interactúe con redis, y el propio servidor de Redis.
1 |
apt-get install python-pip redis-server
|
2 |
pip install redis bottle
|
Una vez que estos terminen, vamos a confirmar esta imagen. Desde otra ventana de terminal, ejecute el siguiente comando:
1 |
docker ps |
... y tome nota del ID y comprométalo bajo el nombre de tuts/pyredis:
1 |
docker commit tuts/pyredis |
Por lo tanto, ahora tenemos una imagen de Docker que contiene las herramientas necesarias para ejecutar una pequeña aplicación web de Python con Redis que actúa como back-end. Si tiene proyectos futuros que usarán la misma pila, todo lo que tiene que hacer para comenzar es: docker run -t -i tuts/pyredis /bin/bash y confirmar una vez que haya agregado su código fuente.
Ok, así que nuestro backend está configurado. Ahora para configurar la aplicación en sí!
Introducción de la aplicación de origen en la imagen
He creado una pequeña aplicación de ejemplo que hace uso de los módulos de Redis y Python que hemos instalado hasta ahora. La aplicación es bastante simple, todo lo que hace es mostrar una lista de las claves de Redis y proporciona una interfaz rudimentaria para agregarlas y editarlas. Vamos a obtener el código fuente en su máquina host (la sesión ssh vagabundo) primero:
1 |
cd
|
2 |
git clone https://github.com/nikvdp/tuts-docker.git pyredis |
En el directorio de inicio de su máquina host ahora tendrá una carpeta pyredis que contiene el script de Python que usaremos. Entonces, ¿cómo hacemos para copiar esta aplicación en nuestra imagen de Docker?
Bueno, Docker tiene una buena característica que le permite montar un directorio local dentro de su contenedor. Vamos a ejecutar otra imagen de Docker y montar la carpeta:
1 |
docker run -v ~/pyredis:/tuts:rw -t -i tuts/pyredis /bin/bash |
Esto es igual que nuestros comandos run de antes, con la adición del parámetro -v.
En efecto, este comando le permite compartir una carpeta entre Docker y la máquina host. Los :'s indican las rutas de acceso a compartir. En nuestro caso, estamos compartiendo nuestra carpeta pyredis, ubicada en ~/pyredis en nuestra máquina, y montándola en /tuts dentro de la imagen de Docker. El rw al final es para 'lectura y escritura' y significa que los cambios realizados en la imagen de Docker también se mostrarán en nuestra máquina.
En el símbolo del sistema de Docker, ahora puede hacer lo siguiente:
1 |
cd /tuts
|
2 |
ls
|
... y vea el contenido de la carpeta ~/pyredis en su máquina.
Sin embargo, este recurso compartido es temporal, si ejecuta esta imagen de Docker en otro equipo o vuelve a ejecutar esta imagen sin la opción -v, la imagen ya no tendrá acceso a ella. Vamos a copiarlo en otra ubicación dentro de la imagen real de Docker:Let's copy it to another location inside the actual Docker image:
1 |
cp -R /tuts/ /pyredis |
Dado que los cambios en los sistemas de archivos de Docker son efímeros de forma predeterminada, guardemos esto en la imagen haciendo de nuevo docker ps para obtener nuestro ID de contenedor y confirmando nuestros cambios:
1 |
docker commit tuts/pyredis |
Notarás aquí que nos comprometimos con el mismo nombre de imagen con el que nos comprometimos la última vez, tuts / pyredis. Docker actualizará la imagen y mantendrá un registro de todos los cambios por usted. Al igual que git, si te equivocas, puedes volver a una buena versión simplemente por docker run'ing su ID. Para ver el historial de una imagen, intente lo siguiente:
1 |
docker history tuts/pyredis
|
Verás algo como esto:
1 |
ID CREATED CREATED BY |
2 |
tuts/pyredis:latest 17 seconds ago /bin/bash |
3 |
4c3712e7443c 25 hours ago /bin/bash |
4 |
ubuntu:12.10 6 months ago /bin/bash |
5 |
27cf78414709 6 months ago |
Esta es una historia de todos los commits que hicimos en el proceso de creación de la imagen de tuts / pyredis, incluidos los que cometieron con diferentes nombres como tuts / python. Si quieres volver a la confirmación justo antes de copiar nuestra aplicación pyredis en /pyredis, puedes intentarlo (cambiar los identificadores para que coincidan con lo que muestra el tuyo):
1 |
docker run -t -i 4c3712e7443c /bin/bash |
... y encontrará que no hay ningún directorio /pyredis.
Ejecución de la aplicación
Así que ahora tenemos todas las piezas en su lugar. El siguiente paso es ejecutar realmente la aplicación desde dentro de su contenedor. Dado que estamos implementando una aplicación web, también tendremos que especificar alguna forma de acceder a la aplicación a través de la web. El comando run te tiene cubierto (de nuevo). El comando run de Docker admite una opción -p que le permite especificar cómo se asignarán los puertos.
Si usa Vagrant para ejecutar Docker, deberá configurar el reenvío de puertos de Vagrant antes de que podamos realizar pruebas significativas. Si no está usando Vagrant, simplemente omita este paso.
Configuración de vagrant port forwards
Si usa Vagrant para probar esto, deberá configurar el reenvío de puertos para que el explorador web de su máquina local pueda acceder a los puertos de la máquina virtual Vagrant, que a su vez reenviará al puerto de la instancia de Docker. Por lo tanto, en nuestro caso, configuraremos el puerto 9000 de nuestra máquina local para reenviarlo al 9000 de nuestra máquina virtual Vagrant, que a su vez se remite al puerto 8080 de nuestra instancia de Docker tuts/pyredis.
En el equipo local, vuelva a la carpeta donde escribió por primera vez vagrant init. Allí encontrarás un archivo de texto llamado simplemente Vagrantfile. Ábralo en su editor de texto favorito y busque la siguiente parte:
1 |
# Create a forwarded port mapping which allows access to a specific port
|
2 |
# within the machine from a port on the host machine. In the example below,
|
3 |
# accessing "localhost:8080" will access port 80 on the guest machine.
|
4 |
# config.vm.network "forwarded_port", guest: 80, host: 8080
|
Quite los comentarios de la línea final y cambie los puertos de 80 y 8080 a 8080 y 9000. El resultado debería tener este aspecto:
1 |
# Create a forwarded port mapping which allows access to a specific port
|
2 |
# within the machine from a port on the host machine. In the example below,
|
3 |
# accessing "localhost:8080" will access port 80 on the guest machine.
|
4 |
config.vm.network "forwarded_port", guest: 8080, host: 9000
|
Ahora ejecute:
1 |
vagrant reload |
... lo que hará que la máquina virtual de Vagrant se reinicie con los reenvíos de puerto correctos. Una vez que esto se haya completado, puede ejecutar vagrant ssh nuevamente y continuar el tutorial.
Nuestra pequeña aplicación pyredis, de forma predeterminada, abre un pequeño servidor web en el puerto 8080. El siguiente comando le permitirá acceder al puerto 8080 a través del puerto 9000 en su máquina host:
1 |
docker run -t -i -p 9000:8080 tuts/pyredis /bin/bash |
Obtendrá un mensaje de raíz de Docker, así que vamos a iniciar nuestra aplicación:
1 |
redis-server 2>&1 > /dev/null &
|
2 |
python /pyredis/app.py |
Si todo va bien, verás lo siguiente:
1 |
Bottle v0.11.6 server starting up (using WSGIRefServer())... |
2 |
Listening on http://localhost:8080/ |
3 |
Hit Ctrl-C to quit. |
Esto significa que el servidor se está ejecutando. En el equipo local, enciéndalo en un explorador web y apunte a localhost:9000 (si está realizando este tutorial en un servidor remoto, asegúrese de que tiene acceso de red al puerto 9000 y reemplace localhost por la dirección de su servidor web).
Con un poco de suerte, deberías ver la pantalla principal de nuestra pequeña aplicación. Siga adelante y agregue algunas claves y cambie algunos valores. Los datos deben conservarse. Sin embargo, si sale del símbolo del sistema de Docker y reinicia Docker, la base de datos volverá a estar vacía, lo que es algo que debe tener en cuenta si planea hospedar la base de datos dentro de un contenedor de Docker.
Guardar la configuración de ejecución
Por lo tanto, todo esto es ideal para las pruebas, pero el objetivo aquí es poder implementar la aplicación. No quieres tener que escribir los comandos para iniciar la aplicación manualmente cada vez.
Docker vuelve a venir al rescate. Al confirmar, Docker puede guardar automáticamente información de ejecución, como qué puertos asignar y qué comandos ejecutar cuando se inicia la imagen. De esta manera, todo lo que tiene que hacer es escribir docker <image_name> y Docker se encargará del resto. Verdadera creación de contenedores.</image_name>
Para nuestro script, solo tenemos dos comandos para ejecutar en el inicio:
1 |
redis-server 2>&1 > /dev/null &
|
2 |
python /pyredis/app.py |
La forma más fácil de hacerlo es crear un pequeño script de inicio que ejecute estos dos comandos. Comencemos nuestros tuts / pyredis de nuevo y agreguemos un pequeño script de lanzamiento (simplemente copie y pegue directamente lo siguiente, en el símbolo del sistema de Docker):
1 |
docker run -t -i tuts/pyredis /bin/bash |
2 |
cat > /pyredis/launch.sh <&1 > /dev/null & |
3 |
#!/bin/sh
|
4 |
python /pyredis/app.py |
5 |
EOF |
6 |
chmod +x /pyredis/launch.sh
|
Esto salvó los comandos que usamos para iniciar nuestro servidor Python en un pequeño script bash llamado launch.sh y establece el bit ejecutable para que sea más fácil de ejecutar.
Ahora que el script está en la imagen correctamente, desde otro terminal, comprométalo para que persista (recuerde hacer un docker ps para obtener primero el ID de su último contenedor):
1 |
docker commit tuts/pyrdis |
Vamos a probar esto. Si sale del símbolo del sistema de Docker y lo ejecuta de nuevo con el siguiente comando, debería poder acceder a la aplicación web de pyredis en localhost:9000, al igual que la última vez.
1 |
docker run -t -i -p 8000:8080 tuts/pyredis /bin/bash /pyredis/launch.sh |
Ok, así que ahora podemos ejecutar nuestra pequeña aplicación con un solo comando. ¡Pero hay más! Docker le permite guardar cierta información de configuración predeterminada con sus confirmaciones. De esa manera, no tenemos que acordarnos de escribir nuestra asignación de puertos e iniciar la información de comandos cada vez y puede simplemente dar una imagen de Docker a otra persona. A continuación, pueden ejecutarlo con una simple ejecución de docker <image_name> y Docker se encarga del resto.
Para configurar esto, debe pasar información JSON al comando commit. Hay muchos parámetros que puede usar, pero por ahora solo nos ocuparemos de la asignación de puertos y scripts de inicialización. Enciende tu editor de texto favorito y pega lo siguiente:
1 |
{
|
2 |
"cmd": [ |
3 |
"/bin/bash",
|
4 |
"/pyredis/launch.sh"
|
5 |
],
|
6 |
"PortSpecs": [ |
7 |
"9000:8080"
|
8 |
]
|
9 |
}
|
Esto representa la información que escribimos en la opción -p, así como la ruta de acceso al script de lanzamiento. Un bit importante a tener en cuenta es que para la opción cmd, cada lugar donde normalmente usaría un espacio se pasa como un parámetro separado.
Guarde ese fragmento de código JSON en un archivo llamado runconfig.json y actualicemos Docker para usarlo.
1 |
docker commit -run=$(cat runconfig.json) tuts/pyredis |
Ahora, si lo haces:
1 |
docker run tuts/pyredis |
Verás el inicio de la botella y podrás acceder a la aplicación a través del navegador.
Implementación de imágenes públicas en un servidor a través del registro público de Docker
Los creadores de Docker han creado un registro público del que cualquiera puede insertar y extraer imágenes de Docker. Esto significa que implementar la nueva aplicación en un servidor remoto es tan fácil como insertarla en el registro central de Docker y, a continuación, extraerla de un servidor donde tiene Docker instalado.
Esto es bastante sencillo, así que te remitiré a la propia documentación de Docker. Si, en cambio, desea implementar de forma privada, siga leyendo en las siguientes secciones.
Implementación de imágenes privadas en un servidor (la forma más sencilla)
Genial, así que ahora tenemos una imagen de Docker fácil de usar que se ejecuta en su máquina. ¡El siguiente paso es implementarlo en un servidor!
Esta parte es un poco complicada. El modelo de distribución de Docker se basa en la idea de repositorios. Puede insertar y extraer sus imágenes de Docker en un repositorio de Docker tanto como desee y diferentes servidores pueden extraer imágenes diferentes. Esto es genial, pero desafortunadamente se requiere un poco de trabajo para alojar su propio repositorio. Si está alojando o creando software de código abierto, puede usar el repositorio público de Docker directamente para almacenar sus imágenes. Sin embargo, si está implementando código propietario, probablemente no desee hacerlo. Esto le deja con dos opciones:
- Puede omitir las características del repositorio de Docker por completo y transferir imágenes manualmente.
- Puede crear su propio repositorio.
La primera es más simple, pero pierde muchas de las características más interesantes de Docker, como mantener los historiales de las imágenes y la capacidad de almacenar la asignación de puertos y ejecutar la configuración dentro de la imagen. Si estos son importantes para usted, vaya a la siguiente sección para obtener información sobre cómo configurar su propio repositorio de Docker (privado). Si solo desea poder implementar las imágenes en los servidores, puede usar este método.
El primer paso es exportar el contenedor a un archivo .tar. Puede hacerlo a través del comando export de Docker.You can do this via Docker's export command. Para implementar la aplicación de ejemplo que hemos estado usando en este tutorial, debe hacer algo como esto:
1 |
docker export > pyredis.tar |
Docker se sentará y procesará durante algún tiempo, pero después tendrá un archivo pyredis.tar que contiene la imagen que creó. A continuación, puede copiar pyredis.tar en el servidor y ejecutar lo siguiente:
1 |
cat pyredis.tar | Docker import -
|
Docker volverá a sentarse durante un tiempo y, finalmente, escupirá el identificador de la nueva imagen que ha creado. Puede confirmar esto con un nombre más memorable haciendo esto:
1 |
docker commit tuts/pyredis |
Nuestra aplicación tutorial ahora está implementada y puede ejecutarla con el mismo comando run que antes:
1 |
docker run -t -i -p 8000:8080 tuts/pyredis /bin/bash /pyredis/launch.sh |
Implementación de imágenes privadas en un servidor (la forma más interesante)
La forma más sencilla de implementar la aplicación es hospedar su propio repositorio de Docker.The cooler way to deploy your app is to host your own Docker repository. Instale Docker en una máquina y ejecute el siguiente comando:Get Docker installed on a machine and run the following command:
1 |
docker run -p 5000:5000 samalba/docker-registry
|
Espere un poco a que descargue las piezas y pronto debería ver algunos mensajes sobre el inicio de unicornio y los trabajadores de arranque.
Esto significa que el registro de Docker está en funcionamiento (dentro de su propio contenedor de Docker) y es accesible para el equipo local en el puerto 5000.This means your Docker registry is up and running (inside its own Docker container), and is accessible to your local machine at port 5000. Un poco alucinante, pero impresionante. Establezcamos primero nuestras credenciales de inicio de sesión y, a continuación, insertemos la imagen de Docker que creamos anteriormente en el tutorial en nuestro nuevo registro. En un nuevo terminal, ejecute lo siguiente
1 |
docker login localhost:5000 |
Siga adelante e introduzca el nombre de usuario, la contraseña y el correo electrónico que desea usar con su repositorio de Docker.
Para insertar la aplicación tuts / pyredis en el repositorio, primero tenemos que "etiquetarla" con la información de la dirección del repositorio privado de la siguiente manera:
1 |
docker tag tuts/pyredis localhost:5000/tuts/pyredis |
Esto indica a Docker que cree una nueva "etiqueta" de tuts/pyredis y la asocie con el repositorio que se ejecuta en localhost:5000.This tells Docker to create a new "tag" of tuts/pyredis and associate it with the repo running at localhost:5000. Puede pensar en esta etiqueta como el nombre de esta imagen en el repositorio. Por coherencia, he mantenido los nombres iguales y lo he etiquetado localhost:5000/tuts/pyredis, pero este nombre podría ser fácilmente algo completamente diferente (como localhost:5000/pyredis_prod).
Si ejecuta imágenes de docker ahora, verá que hay una nueva imagen con el nombre localhost:5000/tuts/pyredis. El mecanismo de Docker para especificar repositorios está estrechamente vinculado a su mecanismo para nombrar (o etiquetar como docker lo pone), por lo que esto es todo lo que necesita.
Para insertar la imagen que hemos creado en nuestro repositorio, simplemente haga docker push y el nombre completo de la imagen etiquetada (incluida la dirección):
1 |
docker push localhost:5000/tuts/pyredis |
Docker se conectará al repositorio que se ejecuta en localhost:5000 y comenzará a insertar los cambios. Verá muchos mensajes sobre las diversas solicitudes HTTP involucradas que aparecen en la otra ventana de terminal (la que ejecuta samalba / docker-registry), y la información sobre la carga pasará en esta. Esto tomará un tiempo, por lo que es posible que desee tomar un café.
Una advertencia, ya que nuestro repositorio de Docker se está ejecutando dentro de un contenedor de Docker, necesitamos confirmar la imagen del repositorio después de terminar de insertar. De lo contrario, dado que los cambios en el sistema de archivos de Docker son efímeros, de forma predeterminada la imagen que insertamos en el repositorio desaparecerá tan pronto como apaguemos nuestro contenedor docker samalba/docker-registry local.
Para ello, realice el docker ps habitual para obtener el identificador del contenedor samalba/docker-registry en ejecución y, a continuación, confirmarlo en un nuevo contenedor. Esto no es ideal, si lo hace en producción, deseará configurar volúmenes de Docker o usar la opción -v desde arriba para conservar el archivo del repositorio directamente en el servidor, en lugar de dentro del contenedor, pero eso está fuera del ámbito de este tutorial.
Ahora para la parte divertida: implementar nuestra nueva imagen de Docker en un nuevo servidor. Dado que en el momento de escribir este artículo, los repositorios de Docker no tienen ningún mecanismo de seguridad o autenticación, haremos nuestro trabajo a través de túneles SSH seguros. Desde la máquina virtual donde configuró el tutorial de tuts / pyredis, ssh en su servidor de producción y reenvíe el puerto 5000 de la siguiente manera:
1 |
ssh -R 5000:localhost:5000 -l |
El indicador -R a ssh significa que cuando se conecta a localhost:5000 en su servidor de producción, SSH reenviará la conexión al puerto 5000 en su máquina virtual, que a su vez se reenvía al contenedor samalba / docker-registry donde vive nuestro repositorio.
Si Docker no está instalado en este servidor, siga adelante e instálelo según las instrucciones de instalación. Una vez que tenga Docker en ejecución, la implementación de la imagen es tan simple como:
1 |
docker pull localhost:5000/tuts/pyredis |
Dado que creamos un túnel a través de SSH, Docker pensará que está tirando del localhost: 5000 del servidor remoto, pero esto de hecho se tunelizará al localhost: 5000 de su máquina virtual local, que a su vez se redirige a Docker. Dele algo de tiempo para descargar, pero una vez que haya terminado, debería poder ejecutar nuestra aplicación pyredis exactamente de la misma manera que la ejecutamos en la máquina virtual original, incluida la configuración y los puertos de ejecución guardados:
1 |
docker run tuts/pyredis |
Resumen y próximos pasos
Así que esos son los conceptos básicos de Docker. Con esta información, ahora puede crear y administrar imágenes de Docker, insertarlas y extraerlas en repositorios públicos y privados e implementarlas en servidores independientes.
Este es un tutorial de introducción, por lo que hay muchas características de Docker que no se trataron aquí. Dos de los más notables son dockerfiles y volúmenes.
Dockerfiles son archivos de texto que Docker puede ejecutar para inicializar y aprovisionar imágenes de Docker.Dockerfiles are text files which Docker can run to initialize and provision Docker images. Pueden hacer que el proceso de creación de muchas imágenes de Docker sea significativamente más rápido, pero dado que el enfoque aquí estaba en cómo crear e implementar una sola imagen, no se cubrieron. Si desea obtener más información sobre ellos, consulte la propia documentación de Docker.If you'd like to learn more about them, check out Docker's own documentation.
La segunda característica son los volúmenes. Los volúmenes funcionan un poco como las carpetas compartidas que cubrimos con la opción -v, en el que permiten que los contenedores de Docker conserven sus datos. A diferencia del uso compartido de carpetas con -v, no se comparten con el sistema host, pero se pueden compartir entre imágenes. Puedes consultar este tutorial para una buena introducción.
