Compartir comentarios
Las respuestas se generan en base a la documentación.

Compilar, etiquetar y publicar una imagen

Tabla de contenidos

Explicación

En esta guía, aprenderás lo siguiente:

  • Compilar imágenes: el proceso de compilar una imagen basada en un Dockerfile
  • Etiquetar imágenes: el proceso de dar un nombre a una imagen, lo que también determina dónde se puede distribuir la imagen
  • Publicar imágenes: el proceso para distribuir o compartir la imagen recién creada utilizando un registro de contenedores

Compilar imágenes

La mayoría de las veces, las imágenes se compilan utilizando un Dockerfile. El comando docker build más básico podría verse así:

docker build .

El . final en el comando proporciona la ruta o URL al contexto de compilación. En esta ubicación, el compilador encontrará el Dockerfile y otros archivos de referencia.

Cuando ejecutas una compilación, el compilador descarga la imagen base, si es necesario, y luego ejecuta las instrucciones especificadas en el Dockerfile.

Con el comando anterior, la imagen no tendrá nombre, pero la salida proporcionará el ID de la imagen. Como ejemplo, el comando anterior podría producir la siguiente salida:

$ docker build .
[+] Building 3.5s (11/11) FINISHED                                              docker:desktop-linux
 => [internal] load build definition from Dockerfile                                            0.0s
 => => transferring dockerfile: 308B                                                            0.0s
 => [internal] load metadata for docker.io/library/python:3.12                                  0.0s
 => [internal] load .dockerignore                                                               0.0s
 => => transferring context: 2B                                                                 0.0s
 => [1/6] FROM docker.io/library/python:3.12                                                    0.0s
 => [internal] load build context                                                               0.0s
 => => transferring context: 123B                                                               0.0s
 => [2/6] WORKDIR /usr/local/app                                                                0.0s
 => [3/6] RUN useradd app                                                                       0.1s
 => [4/6] COPY ./requirements.txt ./requirements.txt                                            0.0s
 => [5/6] RUN pip install --no-cache-dir --upgrade -r requirements.txt                          3.2s
 => [6/6] COPY ./app ./app                                                                      0.0s
 => exporting to image                                                                          0.1s
 => => exporting layers                                                                         0.1s
 => => writing image sha256:9924dfd9350407b3df01d1a0e1033b1e543523ce7d5d5e2c83a724480ebe8f00    0.0s

Con la salida anterior, podrías iniciar un contenedor utilizando la imagen de referencia:

docker run sha256:9924dfd9350407b3df01d1a0e1033b1e543523ce7d5d5e2c83a724480ebe8f00

Ese nombre ciertamente no es memorable, que es donde el etiquetado resulta útil.

Etiquetar imágenes

Etiquetar imágenes es el método para proporcionar a una imagen un nombre memorable. Sin embargo, hay una estructura para el nombre de una imagen. Un nombre completo de imagen tiene la siguiente estructura:

[HOST[:PORT_NUMBER]/]PATH[:TAG]
  • HOST: El nombre de host opcional del registro donde se encuentra la imagen. Si no se especifica ningún host, se utiliza de forma predeterminada el registro público de Docker en docker.io.
  • PORT_NUMBER: El número de puerto del registro si se proporciona un nombre de host
  • PATH: La ruta de la imagen, que consta de componentes separados por barras diagonales. Para Docker Hub, el formato sigue la estructura [NAMESPACE/]REPOSITORY, donde el espacio de nombres (namespace) es el nombre de un usuario o de una organización. Si no se especifica ningún espacio de nombres, se utiliza library, que es el espacio de nombres para las Imágenes Oficiales de Docker.
  • TAG: Un identificador personalizado y legible por humanos que se suele utilizar para identificar diferentes versiones o variantes de una imagen. Si no se especifica ninguna etiqueta, se utiliza latest de forma predeterminada.

Algunos ejemplos de nombres de imágenes incluyen:

  • nginx, equivalente a docker.io/library/nginx:latest: descarga una imagen del registro docker.io, del espacio de nombres library, del repositorio de imágenes nginx y con la etiqueta latest.
  • docker/welcome-to-docker, equivalente a docker.io/docker/welcome-to-docker:latest: descarga una imagen del registro docker.io, del espacio de nombres docker, del repositorio de imágenes welcome-to-docker y con la etiqueta latest.
  • ghcr.io/dockersamples/example-voting-app-vote:pr-311: descarga una imagen del GitHub Container Registry, del espacio de nombres dockersamples, del repositorio de imágenes example-voting-app-vote y con la etiqueta pr-311.

Para etiquetar una imagen durante una compilación, añade la bandera -t o --tag:

docker build -t my-username/my-image .

Si ya has compilado una imagen, puedes añadirle otra etiqueta utilizando el comando docker image tag:

docker image tag my-username/my-image another-username/another-image:v1

Publicar imágenes

Una vez que tengas una imagen compilada y etiquetada, estarás listo para subirla a un registro. Para hacerlo, utiliza el comando docker push:

docker push my-username/my-image

En unos pocos segundos, todas las capas de tu imagen se subirán al registro.

Se requiere autenticación

Antes de poder subir una imagen a un repositorio, deberás estar autenticado. Para hacerlo, simplemente utiliza el comando docker login.

Pruébalo

En esta guía práctica, compilarás una imagen simple utilizando un Dockerfile proporcionado y la subirás a Docker Hub.

Configuración

  1. Obtén la aplicación de muestra.

    Si tienes Git, puedes clonar el repositorio de la aplicación de muestra. De lo contrario, puedes descargar la aplicación de muestra. Elige una de las siguientes opciones.

    Utiliza el siguiente comando en una terminal para clonar el repositorio de la aplicación de muestra.

    $ git clone https://github.com/docker/getting-started-todo-app

    Descarga el código fuente y extráelo.

    Descargar el código fuente

  2. Descarga e instala Docker Desktop.

  3. Si aún no tienes una cuenta de Docker, crea una ahora. Una vez hecho esto, inicia sesión en Docker Desktop con esa cuenta.

Compilar una imagen

Ahora que tienes un repositorio en Docker Hub, es hora de que compiles una imagen y la subas al repositorio.

  1. Utilizando una terminal en la raíz del repositorio de la aplicación de muestra, ejecuta el siguiente comando. Reemplaza YOUR_DOCKER_USERNAME con tu nombre de usuario de Docker Hub:

    $ docker build -t <YOUR_DOCKER_USERNAME>/concepts-build-image-demo .

    Como ejemplo, si tu nombre de usuario es mobywhale, ejecutarías el comando:

    $ docker build -t mobywhale/concepts-build-image-demo .

  2. Una vez finalizada la compilación, puedes ver la imagen utilizando el siguiente comando:

    $ docker image ls

    El comando producirá una salida similar a la siguiente:

    REPOSITORY                             TAG       IMAGE ID       CREATED          SIZE
mobywhale/concepts-build-image-demo    latest    746c7e06537f   24 seconds ago   354MB

  3. Puedes ver el historial (o cómo se creó la imagen) utilizando el comando docker image history:

    $ docker image history mobywhale/concepts-build-image-demo

    A continuación, verás una salida similar a la siguiente:

    IMAGE          CREATED         CREATED BY                                      SIZE      COMMENT
f279389d5f01   8 seconds ago   CMD ["node" "./src/index.js"]                   0B        buildkit.dockerfile.v0
<missing>      8 seconds ago   EXPOSE map[3000/tcp:{}]                         0B        buildkit.dockerfile.v0
<missing>      8 seconds ago   WORKDIR /app                                    8.19kB    buildkit.dockerfile.v0
<missing>      4 days ago      /bin/sh -c #(nop)  CMD ["node"]                 0B
<missing>      4 days ago      /bin/sh -c #(nop)  ENTRYPOINT ["docker-entry…   0B
<missing>      4 days ago      /bin/sh -c #(nop) COPY file:4d192565a7220e13…   20.5kB
<missing>      4 days ago      /bin/sh -c apk add --no-cache --virtual .bui…   7.92MB
<missing>      4 days ago      /bin/sh -c #(nop)  ENV YARN_VERSION=1.22.19     0B
<missing>      4 days ago      /bin/sh -c addgroup -g 1000 node     && addu…   126MB
<missing>      4 days ago      /bin/sh -c #(nop)  ENV NODE_VERSION=20.12.0     0B
<missing>      2 months ago    /bin/sh -c #(nop)  CMD ["/bin/sh"]              0B
<missing>      2 months ago    /bin/sh -c #(nop) ADD file:d0764a717d1e9d0af…   8.42MB

    Esta salida muestra las capas de la imagen, destacando las capas que añadiste y las que heredaste de tu imagen base.

Subir la imagen

Ahora que tienes una imagen compilada, es hora de subirla a un registro.

  1. Sube la imagen utilizando el comando docker push:

    $ docker push <YOUR_DOCKER_USERNAME>/concepts-build-image-demo

    Si recibes un error de tipo requested access to the resource is denied, asegúrate de haber iniciado sesión y de que tu nombre de usuario de Docker sea correcto en la etiqueta de la imagen.

    Después de un momento, tu imagen debería subirse a Docker Hub.

Recursos adicionales

Para obtener más información sobre cómo compilar, etiquetar y publicar imágenes, visita los siguientes recursos:

Siguientes pasos

Ahora que has aprendido a compilar y publicar imágenes, es hora de aprender cómo acelerar el proceso de compilación utilizando la caché de compilación de Docker.

Utilizar la caché de compilación