Docker
Construyendo imagenes

Parámetros

Construyendo una imagen desde un Dockerfile

Una vez que tenga un Dockerfile, puede construir una imagen a partir de él utilizando la docker build . La forma básica de este comando es:

docker build -t image-name path

Si su Dockerfile no se nombra Dockerfile , se puede utilizar el -f pabellón que suministre el nombre de la Dockerfile para construir.

docker build -t image-name -f Dockerfile2 .

Por ejemplo, para crear una imagen llamada dockerbuild-example:1.0.0 partir de un Dockerfile en el directorio de trabajo actual:

$ ls
Dockerfile Dockerfile2

$ docker build -t dockerbuild-example:1.0.0 .

$ docker build -t dockerbuild-example-2:1.0.0 -f Dockerfile2 .

Consulte la documentación de uso de docker build la docker build para obtener más opciones y configuraciones.

Un error común es crear un Dockerfile en el directorio de inicio del usuario ( ~ ). Esta es una mala idea porque durante la docker build -t mytag . Este mensaje aparecerá durante mucho tiempo:

Cargando contexto

La causa es que el demonio docker intenta copiar todos los archivos del usuario (tanto el directorio de inicio como sus subdirectorios). Evite esto especificando siempre un directorio para el Dockerfile.

Agregar un archivo .dockerignore al directorio de compilación es una buena práctica . Su sintaxis es similar a los archivos .gitignore y se asegurará de que solo los archivos y directorios deseados se carguen como contexto de la compilación.

Un simple Dockerfile

FROM node:5

La directiva FROM especifica una imagen para comenzar. Se puede utilizar cualquier referencia de imagen válida.

WORKDIR /usr/src/app

La directiva WORKDIR establece el directorio de trabajo actual dentro del contenedor, equivalente a ejecutar cd dentro del contenedor. (Nota: RUN cd no cambiará el directorio de trabajo actual.)

RUN npm install cowsay knock-knock-jokes

RUN ejecuta el comando dado dentro del contenedor.

COPY cowsay-knockknock.js ./

COPY copia el archivo o directorio especificado en el primer argumento del contexto de construcción (la path pasó a docker build path ) a la ubicación en el contenedor especificado por el segundo argumento.

CMD node cowsay-knockknock.js

CMD especifica un comando para ejecutar cuando la imagen se ejecuta y no se da ningún comando. Puede anularse pasando un comando a la docker run .

Hay muchas otras instrucciones y opciones; vea la referencia de Dockerfile para una lista completa.

Diferencia entre ENTRYPOINT y CMD

Hay dos directivas de Dockerfile para especificar qué comando se ejecutará de forma predeterminada en las imágenes integradas. Si solo especifica CMD , la ENTRYPOINT acoplable ejecutará ese comando usando el ENTRYPOINT predeterminado, que es /bin/sh -c . Puede anular cualquiera de los puntos de entrada y / o el comando al iniciar la imagen construida. Si especifica ambos, entonces ENTRYPOINT especifica el ejecutable de su proceso contenedor, y CMD se suministrará como los parámetros de ese ejecutable.

Por ejemplo, si su Dockerfile contiene

FROM ubuntu:16.04
CMD ["/bin/date"]

Entonces está utilizando la directiva predeterminada ENTRYPOINT de /bin/sh -c , y ejecutando /bin/date con ese punto de entrada predeterminado. El comando de su proceso contenedor será /bin/sh -c /bin/date . Una vez que ejecute esta imagen, por defecto imprimirá la fecha actual

$ docker build -t test .
$ docker run test
Tue Jul 19 10:37:43 UTC 2016

Puede anular CMD en la línea de comando, en cuyo caso ejecutará el comando que ha especificado.

$ docker run test /bin/hostname
bf0274ec8820

Si especifica una directiva ENTRYPOINT , Docker usará ese ejecutable, y la directiva CMD especifica los parámetros predeterminados del comando. Así que si tu Dockerfile contiene:

FROM ubuntu:16.04
ENTRYPOINT ["/bin/echo"]
CMD ["Hello"]

Entonces ejecutarlo producirá

$ docker build -t test .
$ docker run test
Hello

Puede proporcionar diferentes parámetros si lo desea, pero todos se ejecutarán /bin/echo

$ docker run test Hi
Hi

Si desea anular el punto de entrada listado en su Dockerfile (es decir, si desea ejecutar un comando diferente al echo en este contenedor), debe especificar el parámetro --entrypoint en la línea de comandos:

$ docker run --entrypoint=/bin/hostname test
b2c70e74df18

Por lo general, usa la directiva ENTRYPOINT para apuntar a la aplicación principal que desea ejecutar y CMD a los parámetros predeterminados.

Exponiendo un puerto en el Dockerfile

EXPOSE <port> [<port>...]

De la documentación de Docker:

La instrucción EXPOSE informa a Docker que el contenedor escucha en los puertos de red especificados en tiempo de ejecución. EXPOSE no hace que los puertos del contenedor sean accesibles para el host. Para hacerlo, debe usar el indicador -p para publicar un rango de puertos o el indicador -P para publicar todos los puertos expuestos. Puede exponer un número de puerto y publicarlo externamente bajo otro número.

Ejemplo:

Dentro de tu Dockerfile:

EXPOSE 8765

Para acceder a este puerto desde la máquina host, incluya este argumento en su comando de docker run :

-p 8765:8765

ENTRYPOINT y CMD vistos como verbo y parámetro

Supongamos que tiene un archivo Docker que termina con

ENTRYPOINT [ "nethogs"] CMD ["wlan0"]

Si construyes esta imagen con una

docker built -t inspector .

inicie la imagen creada con un archivo Docker con un comando como

docker run -it --net=host --rm inspector

, nethogs monitoreará la interfaz llamada wlan0

Ahora, si quieres monitorear la interfaz eth0 (o wlan1, o ra1 ...), harás algo como

docker run -it --net=host --rm inspector eth0

o

docker run -it --net=host --rm inspector wlan1

Empujando y tirando de una imagen a Docker Hub u otro registro

Las imágenes creadas localmente se pueden enviar a Docker Hub o cualquier otro host de repo docker, conocido como registro. Utilice el docker login de docker login para docker login sesión en una cuenta de concentrador de la ventana acoplable existente.

docker login

Login with your Docker ID to push and pull images from Docker Hub.
If you don't have a Docker ID, head over to https://hub.docker.com to create one.

Username: cjsimon
Password:
Login Succeeded

Se puede utilizar un registro de ventana acoplable diferente especificando un nombre de servidor. Esto también funciona para registros privados o auto alojados. Además, es posible utilizar un almacén de credenciales externo para la seguridad.

docker login quay.io

A continuación, puede etiquetar y enviar imágenes al registro en el que ha iniciado sesión. Su repositorio debe especificarse como server/username/reponame:tag Omitir el servidor actualmente por defecto a Docker Hub. (El registro predeterminado no se puede cambiar a otro proveedor, y no hay planes para implementar esta función).

docker tag mynginx quay.io/cjsimon/mynginx:latest

Se pueden usar diferentes etiquetas para representar diferentes versiones, o ramas, de la misma imagen. Una imagen con múltiples etiquetas diferentes mostrará cada etiqueta en el mismo repositorio.

Use las docker images para ver una lista de las imágenes instaladas instaladas en su máquina local, incluida la imagen recién etiquetada. Luego, presione push para cargarlo en el registro y tire para descargar la imagen.

docker push quay.io/cjsimon/mynginx:latest

Todas las etiquetas de una imagen se pueden extraer especificando la opción -a

docker pull quay.io/cjsimon/mynginx:latest

Construyendo usando un proxy

A menudo, al crear una imagen de Docker, el Dockerfile contiene instrucciones que ejecutan programas para obtener recursos de Internet (por ejemplo, wget para extraer un programa binario construido en GitHub).

Es posible instruir a Docker para que pase las variables de entorno del conjunto establecido para que dichos programas realicen esas recuperaciones a través de un proxy:

$ docker build --build-arg http_proxy=http://myproxy.example.com:3128 \
               --build-arg https_proxy=http://myproxy.example.com:3128 \
               --build-arg no_proxy=internal.example.com \
               -t test .

build-arg son variables de entorno que están disponibles solo en tiempo de compilación.