Publicación de imágenes de Docker

Puedes publicar imágenes de Docker en un registro, tale como Docker Hub o GitHub Packages, como parte de tu flujo de trabajo de integración continua (IC).

En este artículo

Introducción

Esta guía te muestra cómo crear un flujo de trabajo que realiza una compilación de Docker y posteriormente publica las imágenes de Docker en Docker Hub o GitHub Packages. Con un solo flujo de trabajo, puedes publicar imágenes a un solo registro o a varios de ellos.

Note

Si quieres enviar cambios a otro registro de Docker de terceros, el ejemplo de la sección "Publicar imágenes en GitHub Packages" puede servir como plantilla.

Requisitos previos

Recomendamos que tengas un conocimiento básico de las opciones de configuración de flujo de trabajo y de cómo crear un archivo de flujo de trabajo. Para obtener más información, vea «Escritura de flujos de trabajo».

También puede que encuentres útil el tener un entendimiento básico de lo siguiente:

Acerca de la configuración de imágenes

Esta guía asume que tienes una definición completa de una imagen de Docker almacenada en un repositorio de GitHub. Por ejemplo, su repositorio debe contener un Dockerfile y cualquier otro archivo que se necesite para realizar una compilación de Docker a fin de crear una imagen.

Puedes usar etiquetas claves de anotación predefinidas para agregar metadatos, incluida una descripción, una licencia y un repositorio de origen a la imagen de contenedor. Para más información, consulta "Trabajar con el registro de contenedores".

En esta guía, utilizaremos la acción build-push-action de Docker para compilar la imagen de Docker e insertarla en uno o varios registros de Docker. Para más información, vea build-push-action.

Publicar imágenes en Docker Hub

Cada vez que creas una nueva versión en GitHub Enterprise Cloud, puedes desencadenar un flujo de trabajo para publicar tu imagen. El flujo de trabajo del ejemplo siguiente se ejecuta cuando se desencadena el evento release con el tipo de actividad published.

En el siguiente ejemplo de flujo de trabajo, utilizamos las acciones login-action y build-push-action de Docker para compilar la imagen de Docker y, si la compilación se realiza correctamente, insertar la imagen compilada en Docker Hub.

Para hacer una carga en Docker hub, necesitarás tener una cuenta de Docker Hub y haber creado un repositorio ahí mismo. Para obtener más información, vea "Insertar una imagen de contenedor Docker en Docker Hub" en la documentación de Docker.

Las opciones login-action necesarias para Docker Hub son las siguientes:

  • username y password: son el nombre de usuario y la contraseña de Docker Hub. Te recomendamos almacenar tu nombre de usuario y contraseña de Docker Hub como un secreto para que no se expongan en tu archivo de flujo de trabajo. Para obtener más información, vea «Uso de secretos en Acciones de GitHub».

La opción metadata-action necesaria para Docker Hub es la siguiente:

  • images: el espacio de nombres y el nombre para la imagen de Docker que está compilando o insertando en Docker Hub.

Las opciones build-push-action necesarias para Docker Hub son las siguientes:

  • tags: la etiqueta de la nueva imagen con el formato DOCKER-HUB-NAMESPACE/DOCKER-HUB-REPOSITORY:VERSION. Puedes configurar una etiqueta sencilla como se muestra a continuación o especificar etiquetas múltiples en una lista.
  • push: si se establece en true, la imagen se insertará en el registro si se ha compilado correctamente.
YAML
# Este flujo de trabajo usa acciones que no GitHub no certifica.
# Estas las proporcionan entidades terceras y las gobiernan
# condiciones de servicio, políticas de privacidad y documentación de soporte
# en línea.

# GitHub recomienda anclar acciones a un SHA de confirmación.
# Para obtener una versión más reciente, debes actualizar el SHA.
# También puedes hacer referencia a una etiqueta o rama, pero la acción puede cambiar sin ninguna advertencia.

name: Publish Docker image

on:
  release:
    types: [published]

jobs:
  push_to_registry:
    name: Push Docker image to Docker Hub
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
      attestations: write
      id-token: write
    steps:
      - name: Check out the repo
        uses: actions/checkout@v4

      - name: Log in to Docker Hub
        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Extract metadata (tags, labels) for Docker
        id: meta
        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
        with:
          images: my-docker-hub-namespace/my-docker-hub-repository

      - name: Build and push Docker image
        id: push
        uses: docker/build-push-action@3b5e8027fcad23fda98b2e3ac259d8d67585f671
        with:
          context: .
          file: ./Dockerfile
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}

      - name: Generate artifact attestation
        uses: actions/attest-build-provenance@v1
        with:
          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
          subject-digest: ${{ steps.push.outputs.digest }}
          push-to-registry: true

El flujo de trabajo anterior comprueba el repositorio de GitHub, utiliza login-action para iniciar sesión en el registro y luego utiliza la acción build-push-action para lo siguiente: compilar una imagen de Docker basada en el elemento Dockerfile del repositorio; insertar la imagen en Docker Hub y aplicar una etiqueta a la imagen.

En el último paso, genera una atestación de artefacto para la imagen, lo que aumenta la seguridad de la cadena de suministro. Para obtener más información, vea «Uso de atestaciones de artefactos para establecer la procedencia de las compilaciones».

Publicar imágenes en GitHub Packages

Cada vez que creas una nueva versión en GitHub Enterprise Cloud, puedes desencadenar un flujo de trabajo para publicar tu imagen. El flujo de trabajo del ejemplo siguiente se ejecuta cuando se inserta un cambio en la rama release.

En el flujo de trabajo de ejemplo siguiente, utilizamos las acciones login-action, metadata-action y build-push-action de Docker para compilar la imagen de Docker y, si la compilación se realiza correctamente, insertar la imagen compilada en GitHub Packages.

Las opciones login-action necesarias para GitHub Packages son las siguientes:

La opción metadata-action necesaria para GitHub Packages es la siguiente:

  • images: el espacio de nombres y el nombre de la imagen de Docker que está compilando.

Las opciones build-push-action necesarias para GitHub Packages son las siguientes:

  • context: define el contexto de compilación como el conjunto de archivos que se ubican en la ruta de acceso especificada.
  • push: si se establece en true, la imagen se insertará en el registro si se ha compilado correctamente.
  • tags y labels: se rellenan mediante la salida de metadata-action.

Note

  • Este flujo de trabajo usa acciones que no están certificadas por GitHub. Las proporciona un tercero y se rigen por los términos de servicio independientes, la directiva de privacidad y la documentación de soporte técnico.
  • GitHub recomienda las acciones de anclaje a un SHA de confirmación. Para obtener una versión más reciente, debes actualizar el SHA. También puedes hacer referencia a una etiqueta o rama, pero la acción puede cambiar sin ninguna advertencia.
YAML
name: Create and publish a Docker image
on:
  push:
    branches: ['release']

Configures this workflow to run every time a change is pushed to the branch called release.

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

Defines two custom environment variables for the workflow. These are used for the Container registry domain, and a name for the Docker image that this workflow builds.

jobs:
  build-and-push-image:
    runs-on: ubuntu-latest

There is a single job in this workflow. It's configured to run on the latest available version of Ubuntu.

    permissions:
      contents: read
      packages: write
      attestations: write
      id-token: write

Sets the permissions granted to the GITHUB_TOKEN for the actions in this job.

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      - name: Log in to the Container registry
        uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

Uses the docker/login-action action to log in to the Container registry registry using the account and password that will publish the packages. Once published, the packages are scoped to the account defined here.

      - name: Extract metadata (tags, labels) for Docker
        id: meta
        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}

This step uses docker/metadata-action to extract tags and labels that will be applied to the specified image. The id "meta" allows the output of this step to be referenced in a subsequent step. The images value provides the base name for the tags and labels.

      - name: Build and push Docker image
        id: push
        uses: docker/build-push-action@f2a1d5e99d037542a71f64918e516c093c6f3fc4
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}

This step uses the docker/build-push-action action to build the image, based on your repository's Dockerfile. If the build succeeds, it pushes the image to GitHub Packages. It uses the context parameter to define the build's context as the set of files located in the specified path. For more information, see "Usage" in the README of the docker/build-push-action repository. It uses the tags and labels parameters to tag and label the image with the output from the "meta" step.

      - name: Generate artifact attestation
        uses: actions/attest-build-provenance@v1
        with:
          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
          subject-digest: ${{ steps.push.outputs.digest }}
          push-to-registry: true

This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see "Uso de atestaciones de artefactos para establecer la procedencia de las compilaciones."

#
name: Create and publish a Docker image

# Configures this workflow to run every time a change is pushed to the branch called `release`.
on:
  push:
    branches: ['release']

# Defines two custom environment variables for the workflow. These are used for the Container registry domain, and a name for the Docker image that this workflow builds.
env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

# There is a single job in this workflow. It's configured to run on the latest available version of Ubuntu.
jobs:
  build-and-push-image:
    runs-on: ubuntu-latest
    # Sets the permissions granted to the `GITHUB_TOKEN` for the actions in this job.
    permissions:
      contents: read
      packages: write
      attestations: write
      id-token: write
      # 
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      # Uses the `docker/login-action` action to log in to the Container registry registry using the account and password that will publish the packages. Once published, the packages are scoped to the account defined here.
      - name: Log in to the Container registry
        uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      # This step uses [docker/metadata-action](https://github.com/docker/metadata-action#about) to extract tags and labels that will be applied to the specified image. The `id` "meta" allows the output of this step to be referenced in a subsequent step. The `images` value provides the base name for the tags and labels.
      - name: Extract metadata (tags, labels) for Docker
        id: meta
        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
      # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
      # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)" in the README of the `docker/build-push-action` repository.
      # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
      - name: Build and push Docker image
        id: push
        uses: docker/build-push-action@f2a1d5e99d037542a71f64918e516c093c6f3fc4
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
      
      # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see "[AUTOTITLE](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds)." 
      - name: Generate artifact attestation
        uses: actions/attest-build-provenance@v1
        with:
          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
          subject-digest: ${{ steps.push.outputs.digest }}
          push-to-registry: true

El flujo de trabajo anterior se activa mediante una subida a la rama "release". Comprueba el repositorio de GitHub y utiliza login-action para iniciar sesión en Container registry. Luego extrae las etiquetas y marcas de la imagen de Docker. Finalmente, utiliza la acción build-push-action para compilar la imagen y publicarla en el Container registry.

Publicar imágenes en Docker Hub y en GitHub Packages

En un solo flujo de trabajo, puede publicar su imagen de Docker en varios registros mediante las acciones login-action y build-push-action para cada uno de ellos.

En el flujo de trabajo de ejemplo siguiente se usan los pasos de las secciones anteriores ("Publicar imágenes en Docker Hub" y "Publicar imágenes en GitHub Packages") para crear un único flujo de trabajo que inserte en ambos registros.

YAML
# Este flujo de trabajo usa acciones que no GitHub no certifica.
# Estas las proporcionan entidades terceras y las gobiernan
# condiciones de servicio, políticas de privacidad y documentación de soporte
# en línea.

# GitHub recomienda anclar acciones a un SHA de confirmación.
# Para obtener una versión más reciente, debes actualizar el SHA.
# También puedes hacer referencia a una etiqueta o rama, pero la acción puede cambiar sin ninguna advertencia.

name: Publish Docker image

on:
  release:
    types: [published]

jobs:
  push_to_registries:
    name: Push Docker image to multiple registries
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
      attestations: write
      id-token: write
    steps:
      - name: Check out the repo
        uses: actions/checkout@v4

      - name: Log in to Docker Hub
        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Log in to the Container registry
        uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract metadata (tags, labels) for Docker
        id: meta
        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
        with:
          images: |
            my-docker-hub-namespace/my-docker-hub-repository
            ghcr.io/${{ github.repository }}

      - name: Build and push Docker images
        id: push
        uses: docker/build-push-action@3b5e8027fcad23fda98b2e3ac259d8d67585f671
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}

      - name: Generate artifact attestation
        uses: actions/attest-build-provenance@v1
        with:
          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
          subject-digest: ${{ steps.push.outputs.digest }}
          push-to-registry: true

El flujo de trabajo anterior comprueba el repositorio GitHub Enterprise Cloud, utiliza login-action dos veces para iniciar sesión en ambos registros y genera etiquetas con la acción metadata-action. Después, la acción build-push-action compila la imagen de Docker y la inserta en Docker Hub y en el Container registry.

En el último paso, genera una atestación de artefacto para la imagen, lo que aumenta la seguridad de la cadena de suministro. Para obtener más información, vea «Uso de atestaciones de artefactos para establecer la procedencia de las compilaciones».