Share
A las personas que hacen Docker les gusta describirlo utilizando una metáfora de una tecnología bastante antigua: el contenedor de envío..
Si bien ahora ni siquiera pensamos en ellos ni los notamos, el contenedor de envío era en realidad una tecnología bastante revolucionaria en su momento. Sin importar la forma o el tamaño del artículo original, al usar un contenedor estandarizado, el propietario del bote / avión / camión / lo que tenga, pudo determinar fácilmente cuántos recursos necesitaban para asignar.
Docker intenta tomar este mismo nivel de conveniencia y llevarlo al mundo del servidor. Es la extensión natural de herramientas como Vagrant que le permite implementar la misma máquina virtual que utiliza en los entornos de desarrollo para producción. Las máquinas virtuales de estilo vagabundo son geniales, pero son pesadas. Se requieren muchos recursos para ejecutarse, muchos de los cuales son redundantes: una imagen de Vagrant carga una copia nueva de Linux dentro de una existente. ¿No sería mejor si pudiera usar la conveniencia y uniformidad de Vagrant pero no tuviera que recargar todo el sistema operativo? Bueno, eso es exactamente lo que hace Docker..
En este tutorial, lo guiaré a través de todo el flujo de trabajo de Docker. Primero, seguiremos los pasos para obtener una aplicación web Python simple que tenga un par de dependencias de Python y que dependa de una base de datos Redis para la persistencia y funcionamiento. Luego instalaremos Docker e instalaremos todos los requisitos de la aplicación web (dependencias de Redis, Python y Python) en una imagen de Docker. Luego usaremos esa imagen y la implementaremos en un servidor diferente.
Simplemente desplegaremos una aplicación de muestra de juguete, 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 por completo el tutorial e implementar la aplicación, también necesitará una segunda máquina (o segunda máquina virtual) para implementar.
El primer paso es instalar Docker. Docker está en desarrollo muy rápido, por lo que la forma más fácil de instalarlo cambia a menudo con bastante rapidez. Echa un vistazo a la sección de inicio de Docker si quieres revisar la vanguardia.
De lo contrario, siga los pasos a continuación y configuraremos una instalación de Docker basada en una máquina virtual Vagrant que funcionará en cualquiera de los principales sistemas operativos. Primero, dirígete al sitio web de Vagrant e instala los últimos Vagrant y VirtualBox para tu sistema operativo.
Una vez que Vagrant esté instalado, cree una nueva carpeta, abra un símbolo del sistema allí y haga lo siguiente:
vagrant init hashicorp / precise64 (... espera un momento ...) vagrant up vagrant ssh
Vagrant se encargó de crear una máquina virtual que ejecuta Ubuntu 12.04 para ti y ahora estás SSH en su mensaje. Ahora podemos seguir las instrucciones de instalación de Docker en Ubuntu. Consulte el sitio web en caso de que haya habido cambios desde que se escribió, pero lo más probable es que pueda pegar directamente los siguientes comandos en el terminal:
# instale el kernel backported sudo apt-get update sudo apt-get instale linux-image-generic-lts-raring linux-headers-generic-lts-raring # reiniciar sudo reiniciar
Cuando la máquina virtual se reinicie, volverá al indicador de su máquina local, así que espere unos momentos y haga otra:
vagabundo ssh
... para volver a SSH en su máquina virtual. Ahora que los requisitos previos de Docker se han instalado correctamente, debemos seguir adelante e instalar Docker. Pega el siguiente comando:
curl -s https://get.docker.io/ubuntu/ | sudo sh
... que tomará un simple script de instalación de Docker del sitio de Docker y lo ejecutará. Docker ahora debería instalarse correctamente, así que comencemos a jugar con él..
Una vez apt-get ha terminado su magia, haz lo siguiente:
sudo Docker ejecuta -i -t ubuntu / bin / bash
... para comprobar y ver que la instalación fue exitosa. Si funciona, Docker procederá a descargar una imagen de Ubuntu Docker y después de un tiempo, terminará en lo que parece ser un indicador de raíz. Siéntase libre de jugar un rato, notará que se encuentra en un entorno completamente separado de su máquina host. Probablemente notaste la raíz y # iniciar sesión en el indicador. Se está ejecutando como usuario root en un nuevo entorno virtual. Si usted emite un usuarios comando, verás que tus otros usuarios ya no están presentes.
Vale la pena tomarse un minuto para explicar lo que el estibador El comando que acaba de escribir hizo y cómo sucedió esta magia.
Accentsconagua
correr MandoLa utilidad Docker parece haber tomado mucha inspiración de gitLa interfaz de línea de comandos y, como resultado, utiliza subcomandos. En este caso, corrimos el correr subcomando los correr comando 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á una para usted. Aquí le decimos que ejecute un ubuntu Imagen e informo a Docker de que debería empezar. / bin / bash dentro de esa imagen los -t y -yo dígale a Docker que asigne un TTY y que se ejecute en "modo interactivo", en otras palabras, para obtener un indicador de comando. La razón de esto es que Docker funciona un poco diferente de otro software de virtualización con el que pueda estar familiarizado. Las imágenes de Docker no se "inician", simplemente se ejecutan. Están utilizando la instalación existente de Linux, por lo que iniciar una imagen de Docker puede ser inmediato. De alguna manera Docker está más cerca de Linux chroot comando que a las herramientas de virtualización más tradicionales como VMWare o VirtualBox.
Existen algunas otras diferencias clave con respecto a las herramientas de virtualización estándar. Hagamos un experimento rápido y creemos un archivo e imprimamos su contenido:
echo un experimento> experiment.txt
Ahora cuando lo hagas:
gato experiment.txt
Felizmente se imprimirá:
Un experimento
Hasta ahora, bien, nuestro experimento tonto está funcionando exactamente como se esperaba. Salgamos de Docker y regresemos a la línea de comandos de nuestra máquina host:
salida
Si reinicia Docker con el mismo comando que usó antes:
sudo Docker ejecuta -i -t ubuntu / bin / bash
... te darás cuenta de que las cosas ya no se comportan de la forma que esperas. Si intenta actualizar el archivo que creamos la última vez, ahora aparece un mensaje de error:
root @ e97acdf4160c: / # cat experiment.txt cat: experiment.txt: No existe tal archivo o directorio
Entonces, ¿qué está pasando? Los cambios en las imágenes de Docker no persisten de forma predeterminada. Para guardar sus cambios en una imagen de Docker, debe cometer ellos, git estilo. Esto puede tardar un poco en acostumbrarse, pero es bastante poderoso porque significa que también puedes "ramificar" git estilo (más sobre eso más adelante).
Por ahora, hagamos algo un poco más útil. Vamos a instalar pitón, Redis y algunas otras utilidades que usaremos para ejecutar nuestra aplicación de demostración en breve. Después, vamos a cometer para persistir nuestros cambios. Inicie una copia de Docker en la última imagen de Ubuntu:
ventana acoplable -t -i ubuntu / bin / bash
Es posible que la imagen base de Ubuntu no incluya Python, así que compruebe si tiene una copia escribiendo pitón en el aviso Si recibe un mensaje de error, entonces instálelo:
apt-get update apt-get instala python
Hasta ahora tan bueno. Es posible que luego queramos hacer otros proyectos que utilicen Python, así que sigamos adelante y guardemos estos cambios. Abra otro indicador de comando (si está usando la instalación recomendada de Vagrant arriba, deberá vagabundo ssh de nuevo desde un aviso separado) y haga lo siguiente:
docker ps
Obtendrá una lista como la siguiente, de todos los contenedores de Docker que se están ejecutando actualmente:
ID DE IMAGEN COMANDO PUESTO DE ESTADO CREADO 54a11224dae6 ubuntu: 12.04 / bin / bash Hace 6 minutos Hasta 6 minutos
El número debajo de 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 nuevamente, verá un nuevo número allí..
Ahora que hemos instalado Python, guardemos nuestros cambios. Para ello utiliza el cometer comando que toma dos argumentos: el contenedor cuyos cambios 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. Ejecute el siguiente comando para guardar su instalación de Python, asegurándose de sustituir el ID de su contenedor del último paso
docker commit tuts / python
Después de unos segundos, regresará con una serie de letras y números. Este es el ID de la imagen que acabas de guardar. Puede ejecutar esta imagen cuando lo desee y referirse a ella por medio de este número de identificación o por el más fácil de recordar tuts / python nombre que le asignamos.
Vamos a ejecutar una copia de la imagen que acabamos de hacer:
ventana acoplable ejecutada -t -i tuts / python / bin / bash
En este punto, debe tener abiertas dos ventanas de terminal ejecutando dos sesiones de Docker separadas.
Notarás ahora que si escribes pitón en cualquiera de los dos, ya no recibirá un mensaje de error. Intenta crear un archivo en la segunda ventana:
touch / testfile
Ahora vuelva a la ventana original de Docker e intente mirar el archivo:
cat / testfile
Recibirás 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 docker commit mando. Sus sistemas de archivos son completamente separados.
Si abre otra terminal (de nuevo, tendrá que ejecutar vagabundo ssh Si usa Vagrant) y haga lo siguiente:
docker ps
... ya verás eso estibador ahora muestra dos imágenes en ejecución, no solo una. Puede comprometerse por separado a cada una de esas imágenes. Para continuar con la git metáfora, ahora estás trabajando con dos ramas y son libres de "divergir".
Sigamos adelante y cerremos la última ventana que abrimos. Si tu corres docker ps de nuevo, ahora solo habrá una identificación en la lista. ¿Pero qué pasa si desea volver a un contenedor anterior? Si escribe:
docker ps -a
Docker también listará todos los contenedores anteriores. No puede ejecutar un contenedor que haya salido, pero puede usar las ID de los contenedores anteriores para enviar nuevas imágenes. Al ejecutar la nueva imagen, volverá al estado de su contenedor anterior..
Cerremos las nuevas ventanas que abrimos y volvamos al terminal para la primera sesión de Docker que comenzamos. Una vez más, siga adelante e instale algunas herramientas más para nuestra pequeña aplicación. En este caso, necesitamos instalar el gestor de paquetes de Python, dos módulos de Python para que Python actúe como un servidor web e interactúe con Redis, y el propio servidor Redis.
apt-get install python-pip redis-server pip instala redis bottle
Una vez que estos terminen, vamos a cometer esta imagen. Desde otra ventana de terminal, ejecute el siguiente comando:
docker ps
... y tome nota de la identificación y confírmela con el nombre tuts / pyredis:
docker commit tuts / pyredis
Así que ahora tenemos una imagen de Docker que contiene las herramientas necesarias para ejecutar una pequeña aplicación web de Python con Redis como backend. Si tiene proyectos futuros que usarán la misma pila, todo lo que tiene que hacer para comenzar es: ventana acoplable ejecutada -t -i tuts / pyredis / bin / bash y cometer una vez que haya agregado su código fuente.
Ok, entonces nuestro backend está configurado. Ahora para configurar la propia aplicación!
He creado una pequeña aplicación de ejemplo que utiliza los módulos Redis y Python que hemos instalado hasta ahora. La aplicación es bastante simple, todo lo que hace es mostrar una lista de las teclas Redis y proporciona una interfaz rudimentaria para agregarlas y editarlas. Pongamos el código fuente en su máquina host (la vagabundo ssh sesión) primero:
cd git clone https://github.com/nikvdp/tuts-docker.git pyredis
En el directorio de inicio de su máquina host ahora tendrá una pirida carpeta que contiene el script Python que vamos a utilizar. Entonces, ¿cómo hacemos para copiar esta aplicación en nuestra imagen Docker??
Bueno, Docker tiene una buena característica que te permite montar un directorio local dentro de tu contenedor. Ejecutemos otra imagen de Docker y montemos la carpeta:
ventana acoplable ejecutar -v ~ / pyredis: / tuts: rw -t -i tuts / pyredis / bin / bash
Esto es igual que nuestro correr comandos de antes, con la adición de la -v parámetro.
En efecto, este comando le permite compartir una carpeta entre Docker y su máquina host. los :'s indican los caminos para compartir. En nuestro caso, estamos compartiendo nuestra pirida carpeta, ubicada en ~ / pyredis en nuestra maquina, y montandolo en / tuts Dentro de la imagen de Docker. los rw en el extremo es para 'lectura-escritura' y significa que los cambios realizados en la imagen de Docker también se mostrarán en nuestra máquina.
A su solicitud de Docker, ahora puede hacer:
cd / tuts ls
… Y ver los contenidos de la ~ / pyredis carpeta en su máquina.
Sin embargo, este recurso compartido es temporal, si ejecuta esta imagen de Docker en otra computadora o si vuelve a ejecutar esta imagen sin el -v Opción, la imagen ya no tendrá acceso a ella. Vamos a copiarlo en otra ubicación dentro de la imagen real de Docker:
cp -R / tuts / / pyredis
Como los cambios en los sistemas de archivos de Docker son efímeros por defecto, guardemos esto en la imagen nuevamente haciendo docker ps para obtener nuestra identificación de contenedor y cometer nuestros cambios:
docker commit tuts / pyredis
Notarás que aquí nos comprometimos con el mismo nombre de imagen que comprometimos la última vez, tuts / pyredis. Docker actualizará la imagen y mantendrá un registro de todos sus cambios para usted. Me gusta git, Si te equivocas, puedes volver a una buena versión simplemente ventana acoplable'ing su ID. Para ver el historial de una imagen, prueba lo siguiente:
historia docker tuts / pyredis
Verás algo como esto:
ID CREADA POR Tuts / pyredis: últimos 17 segundos atrás / bin / bash 4c3712e7443c hace 25 horas / bin / bash ubuntu: 12.10 hace 6 meses / bin / bash 27cf78414709 hace 6 meses
Esta es una historia de todos los compromisos que hicimos en el proceso de crear el tuts / pyredis Imagen, incluyendo aquellas que nos comprometimos con diferentes nombres como tuts / python. Si desea volver a la confirmación antes de que copiemos nuestro pirida aplicación en / pyredis Puedes probar (cambiando las ID para que coincida con lo que muestra el tuyo):
ventana acoplable ejecutada -t -i 4c3712e7443c / bin / bash
... y encontrarás que no hay / pyredis directorio.
Así que ahora tenemos todas las piezas en su lugar. El siguiente paso es ejecutar la aplicación desde su contenedor. Como estamos implementando una aplicación web, también necesitaremos especificar alguna forma de acceder a la aplicación a través de la web. los correr El comando te tiene cubierto (otra vez). El comando de ejecución de Docker admite una -pag Opción que le permite especificar cómo se asignarán los puertos..
Si está utilizando Vagrant para ejecutar Docker, deberá configurar el reenvío de puertos de Vagrant antes de que podamos realizar pruebas significativas. Si no estás usando Vagrant, solo salta este paso.
Si está utilizando Vagrant para probar esto, deberá configurar el reenvío de puertos para que el navegador web de su máquina local pueda acceder a los puertos en la máquina virtual Vagrant, que a su vez reenviará al puerto de la instancia de Docker. Entonces, en nuestro caso, configuraremos el puerto 9000 de nuestra máquina local para reenviarlo a nuestro Vagrant VM 9000, que a su vez reenvía a nuestro tuts / pyredis Docker instancia de puerto 8080.
En su máquina local, regrese a la carpeta donde escribió por primera vez inicio vagabundo. Encontrarás un archivo de texto llamado simplemente Vagrantfile. Ábralo en su editor de texto favorito y busque la siguiente porción:
# Cree una asignación de puertos reenviados que permita el acceso a un número de puerto específico dentro de la máquina desde un puerto en la máquina host. En el ejemplo a continuación, # accediendo a "localhost: 8080" accederá al puerto 80 en la máquina invitada. # config.vm.network "forwarded_port", guest: 80, host: 8080
Descomente la línea final y cambie los puertos de 80 y 8080 a 8080 y 9000. El resultado debería verse así:
# Cree una asignación de puertos reenviados que permita el acceso a un número de puerto específico dentro de la máquina desde un puerto en la máquina host. En el ejemplo a continuación, # accediendo a "localhost: 8080" accederá al puerto 80 en la máquina invitada. config.vm.network "forwarded_port", guest: 8080, host: 9000
Ahora ejecuta:
recarga errante
... lo que hará que la máquina virtual Vagrant se reinicie con el puerto correcto hacia delante. Una vez que esto se haya completado, puede ejecutar vagabundo ssh de nuevo y continúa el tutorial.
Nuestro pequeño pirida 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:
ventana acoplable ejecutada -t -i -p 9000: 8080 tuts / pyredis / bin / bash
Obtendrá un indicador de raíz de Docker, así que iniciemos nuestra aplicación:
redis-server 2> & 1> / dev / null & python /pyredis/app.py
Si todo va bien, verás lo siguiente:
El servidor Bottle v0.11.6 se está iniciando (utilizando WSGIRefServer ()) ... Escuchando en http: // localhost: 8080 / Presione Ctrl-C para salir.
Esto significa que el servidor se está ejecutando. En su máquina local, active un navegador web y apúntelo a localhost: 9000 (Si está realizando este tutorial en un servidor remoto, asegúrese de tener acceso a la red al puerto 9000 y reemplace localhost con la dirección de su servidor web).
Con un poco de suerte, deberías ver la pantalla principal de nuestra pequeña aplicación. Continúe y agregue algunas teclas y cambie algunos valores. Los datos deben persistir. Sin embargo, si sale de su indicador 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 alojar su base de datos dentro de un contenedor de Docker.
Así que todo esto es genial para las pruebas, pero el objetivo aquí es poder implementar su aplicación. No quieres tener que escribir los comandos para iniciar tu aplicación manualmente cada vez.
Docker vuelve al rescate. Cuando te comprometes, Docker puede guardar automáticamente cierta información de ejecución, como qué puertos asignar y qué comandos ejecutar cuando comienza la imagen. De esta manera, todo lo que tienes que hacer es teclear. estibador y Docker se encargará del resto. Verdadera contenedorización.
Para nuestro script, solo tenemos dos comandos para ejecutar al inicio:
redis-server 2> & 1> / dev / null & python /pyredis/app.py
La forma más sencilla de hacerlo es crear un pequeño script de inicio que ejecute estos dos comandos. Vamos a empezar nuestro tuts / pyredis de nuevo y agregue un pequeño script de inicio (solo copie y pegue directamente lo siguiente, en el indicador de Docker):
ventana acoplable ejecutada -t -i tuts / pyredis / bin / bash cat> /pyredis/launch.sh <&1 > / dev / null & #! / bin / sh python /pyredis/app.py EOF chmod + x /pyredis/launch.sh
Esto guardó los comandos que utilizamos para iniciar nuestro servidor Python en un pequeño script de 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 con éxito, desde otro terminal, confírmelo para que persista (recuerde hacer un docker ps para obtener su última identificación del contenedor primero):
docker commit tuts / pyrdis
Vamos a probar esto. Si sale de su indicador de Docker y lo ejecuta nuevamente con el siguiente comando, debería poder acceder a la aplicación web de pyredis en localhost: 9000, como la última vez.
ventana acoplable ejecutar -t -i -p 8000: 8080 tuts / pyredis / bin / bash /pyredis/launch.sh
Ok, ahora podemos ejecutar nuestra pequeña aplicación con un solo comando. ¡Pero hay más! Docker te permite guardar información de configuración predeterminada con tus confirmaciones. De esa manera, no tenemos que recordar escribir nuestra asignación de puertos y lanzar la información de comandos cada vez, y usted puede darle una imagen de Docker a otra persona. Entonces pueden ejecutarlo con un simple ventana acoplable y Docker se encarga del resto..
Para configurar esto, debe pasar algo de información JSON al comando commit. Puede usar muchos parámetros, pero por ahora solo nos ocuparemos de los puertos de mapeo y los scripts de inicialización. Encienda su editor de texto favorito y pegue lo siguiente:
"cmd": ["/ bin / bash", "/pyredis/launch.sh"], "PortSpecs": ["9000: 8080"]
Esto representa la información que escribimos en el -pag opción, así como la ruta de acceso a la secuencia de comandos de inicio. Un poco importante a tener en cuenta es que para el cmd opción, cada lugar donde normalmente usaría un espacio se pasa en realidad como un parámetro separado.
Guarda ese fragmento JSON en un archivo llamado runconfig.json y vamos a actualizar Docker para usarlo.
docker commit -run = $ (cat runconfig.json) tuts / pyredis
Ahora si lo haces:
ventana acoplable ejecutar tuts / pyredis
Verás botella Inicia y puedes acceder a la aplicación a través del navegador..
Los creadores de Docker han creado un registro público del que cualquiera puede empujar y extraer imágenes de Docker. Esto significa que la implementación de su nueva aplicación en un servidor remoto es tan fácil como enviarla al registro central de Docker y luego extraerla de un servidor donde tiene instalado Docker.
Esto es bastante sencillo, por lo que lo remitiré a la documentación de Docker. Si, por el contrario, desea realizar una implementación privada, continúe leyendo en la (s) siguiente (s) sección (s).
Genial, ahora tenemos una imagen 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. Puedes empujar y tirar tus imágenes de Docker a un repositorio de Docker todo lo que quieras y diferentes servidores pueden tirar diferentes imágenes. 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 un código propietario, probablemente no quiera hacerlo. Esto te deja con dos opciones:
La primera es más simple, pero pierde muchas de las características más interesantes de Docker, como mantener el historial de sus imágenes y la capacidad de almacenar la asignación de puertos y la configuración de ejecución dentro de la imagen. Si esto es importante para usted, pase a la siguiente sección para aprender cómo configurar su propio repositorio Docker (privado). Si solo desea poder implementar sus imágenes en sus servidores, puede usar este método.
El primer paso es exportar su contenedor a un .alquitrán archivo. Puedes hacerlo a través de Docker. exportar mando. Para implementar la aplicación de ejemplo que hemos estado usando en este tutorial, harías algo como esto:
Exportar ventana acoplable> pyredis.tar
Docker se sentará y procesará durante algún tiempo, pero después tendrá un pyredis.tar Archivo que contiene la imagen que creaste. A continuación, puede copiar pyredis.tar a su servidor y ejecute lo siguiente:
gato pyredis.tar | Docker import -
Docker se sentará nuevamente por un tiempo y finalmente escupirá la identificación de la nueva imagen que ha creado. Usted puede cometer esto a un nombre más memorable haciendo esto:
docker commit tuts / pyredis
Nuestra aplicación de tutorial ya está implementada y puede ejecutarla con el mismo comando de ejecución que antes:
ventana acoplable ejecutar -t -i -p 8000: 8080 tuts / pyredis / bin / bash /pyredis/launch.sh
La forma más sencilla de implementar su aplicación es alojar su propio repositorio de Docker. Instale Docker en una máquina y ejecute el siguiente comando:
ventana acoplable ejecutar -p 5000: 5000 samalba / docker-registry
Espere un poco para que descargue las piezas y pronto verá algunos mensajes sobre cómo iniciar unicornio y arrancar trabajadores..
Esto significa que su registro Docker está activo y en funcionamiento (dentro de su propio contenedor Docker), y es accesible para su máquina local en el puerto 5000. Un poco alucinante, pero asombroso. Primero establezcamos nuestras credenciales de inicio de sesión y luego empujemos la nueva imagen de Docker que creamos anteriormente en el tutorial a nuestro nuevo registro. En una nueva terminal, ejecuta lo siguiente
ventana de inicio de sesión localhost: 5000
Adelante, ingrese el nombre de usuario, la contraseña y el correo electrónico que le gustaría usar con su repositorio Docker.
Para empujar el tuts / pyredis En el repositorio, primero tenemos que "etiquetarlo" con la información de la dirección del repositorio privado, de esta manera:
docker tag tuts / pyredis localhost: 5000 / tuts / pyredis
Esto le dice a Docker que cree una nueva "etiqueta" de tuts / pyredis y asociarlo con el repositorio que se ejecuta en localhost: 5000. Puede pensar en esta etiqueta como el nombre de esta imagen en el repositorio. Por coherencia, he mantenido los nombres iguales y los he etiquetado localhost: 5000 / tuts / pyredis, pero este nombre fácilmente podría ser algo completamente diferente (como localhost: 5000 / pyredis_prod.)
Si tu corres imágenes docker Ahora, verás que hay una nueva imagen listada 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), así que esto es todo lo que necesita.
Para insertar la imagen que hemos creado en nuestro repositorio, simplemente haga empujador docker y el nombre completo de la imagen etiquetada (incluida la dirección):
docker push localhost: 5000 / tuts / pyredis
Docker se conectará a su repositorio ejecutándose en localhost: 5000 y empieza a empujar tus cambios. Verá muchos mensajes sobre las diversas solicitudes HTTP involucradas que aparecen en la otra ventana del terminal (la que se está ejecutando). samalba / docker-registry), y la información sobre la carga pasará en este. Esto tomará un tiempo, por lo que es posible que desee tomar un café.
Una advertencia, dado que nuestro repositorio Docker se está ejecutando dentro de un contenedor Docker, debemos confirmar la imagen del repositorio después de que terminemos de empujar. De lo contrario, dado que los cambios en el sistema de archivos de Docker son efímeros, la imagen que enviamos al repositorio desaparecerá tan pronto como cerremos nuestra red local. samalba / docker-registry Contenedor Docker.
Para ello, haz lo habitual. docker ps para obtener el ID de la carrera samalba / docker-registry Contenedor y luego cometerlo en un nuevo contenedor. Esto no es ideal, si al hacer esto en producción, desearía configurar los volúmenes de Docker o usar el -v Opción desde arriba para conservar el archivo del repositorio directamente en el servidor, en lugar de dentro del contenedor, pero está fuera del alcance 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, realizaremos nuestro trabajo a través de túneles SSH seguros. Desde la máquina virtual donde configuras el tuts / pyredis tutorial, ssh en su servidor de producción y reenvíe el puerto 5000 así:
ssh -R 5000: localhost: 5000 -l
los -R bandera para ssh significa que cuando te conectas 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 reenviará a la samalba / docker-registry contenedor donde vive nuestro repo.
Si Docker no está instalado en este servidor, continúe e instálelo según las instrucciones de instalación. Una vez que tiene Docker en ejecución, desplegar su imagen es tan simple como:
docker pull localhost: 5000 / tuts / pyredis
Dado que creamos un túnel a través de SSH, Docker pensará que se está extrayendo del servidor local del servidor remoto: 5000, pero de hecho esto se canalizará hacia el host local de su máquina virtual local: 5000, que a su vez se redirige a Docker. Dale algo de tiempo para descargar, pero una vez que lo hayas hecho, deberías poder ejecutar nuestra aplicación pyredis exactamente de la misma forma que la ejecutamos en la VM original, incluida la configuración y los puertos de ejecución guar
