Comando Docker Build con múltiples argumentos

El comando docker build nos permite crear imágenes Docker a partir de un Dockerfile. También nos permite construir una imagen a partir de un contexto que hace referencia a un conjunto de archivos ubicados en una ubicación especificada por una RUTA o URL.

Por otro lado, un Dockerfile es simplemente un documento de texto de solo lectura con instrucciones que se llamarán al ensamblar nuestra imagen de Docker. Una imagen de Docker es un conjunto de instrucciones, código de aplicación, dependencias, herramientas y bibliotecas que usamos para crear un contenedor de Docker.

Este tutorial demuestra cómo usar el comando docker build y múltiples argumentos.

el comando docker build con múltiples argumentos

El comando docker build generalmente se ejecuta en la terminal o línea de comandos.

Sintaxis:

docker build [options] <directory path or URL>

La RUTA o URL hace referencia a un conjunto de archivos en un contexto que puede incluir recursos como un contexto tarball preempaquetado, archivos de texto sin formato o incluso un repositorio git. Si todos los archivos están almacenados en el directorio local, es decir, el mismo directorio que el Dockerfile, podemos optar por usar . como el camino.

Esta ruta especifica los archivos utilizados para el contexto de compilación en el demonio docker.

docker build .

Podemos pasar múltiples argumentos durante el tiempo de compilación bajo el parámetro de opciones. Usando la etiqueta –build-arg, podemos establecer valores que los usuarios pueden establecer en el momento de la compilación.

Sin embargo, primero debemos definir una instrucción ARG en nuestro Dockerfile antes de usar la etiqueta --build-arg para construir la imagen. Podemos acceder a esta variable de tiempo de construcción como variables ambientales regulares; sin embargo, no persisten después de generar la imagen.

Aunque el alcance de las instrucciones ARG es limitado, se puede declarar antes de especificar la imagen base. También podemos pasar múltiples argumentos de compilación pasando cada argumento por separado con una etiqueta --build-arg separada.

Sintaxis:

docker build -t <image-name>:<tag> --build-arg <key1>=<value1> --build-arg <key2>=<value2> .

Tenemos un Dockerfile simple que define algunos valores ARG en el siguiente ejemplo. En este caso, no hemos establecido sus valores por defecto.

El archivo Docker se ve como se muestra a continuación.

#  base image
FROM python

ARG language
ARG name
# Set your working directory
WORKDIR /var/www/

# Copy the necessary files
COPY ./app.py /var/www/app.py

# Install the necessary packages
RUN pip install -r /var/www/requirements.txt

RUN echo "Hello $language Developer"
MAINTAINER Isaac Tonyloi

Por lo tanto, se espera que pasemos los valores usando las etiquetas -build-arg al construir la imagen.

~/my-app$ docker build --build-arg language=Java .

Al crear una imagen con el comando anterior, se imprimirá el mensaje Hello Java Developer junto con otros archivos, como se muestra a continuación.

                                                                                                           0.0s
 => [5/6] RUN pip install -r /var/www/requirements.txt                                                                                                                      100.4s
 => [6/6] RUN echo "Hello Java Developer"                                                                                                                                     4.4s
 => exporting to image                                                                                                                                                        3.8s
 => => exporting layers                                                                                                                                                       2.8s
 => => writing image sha256:22fa358b711d2ea3a1d72e59f062f6c7c38b414bdb253fb8d0def20222cadd93

También podemos usar docker build con múltiples comandos usando múltiples etiquetas --build-arg.

/my-app$ docker build \
> --build-arg language=Java \
> --build-arg name=Tonyloi \
> .

Esto imprime el mensaje a continuación y junto con otros mensajes. Aunque esto es muy básico, así es como puede pasar varios comandos al crear una imagen de Docker desde un Dockerfile.

Producción :

 => [2/2] RUN echo "Hello Java Developer and my name is Tonyloi"                                                                                                              3.3s
 => exporting to image                                                                                                                                                        3.0s
 => => exporting layers                                                                                                                                                       2.0s
 => => writing image sha256:d4d7c3b18aa9422be2990f5381a5423a18867dda8090dd4a4f166efc4e7c4ba2