Configura actualizaciones automáticas de imágenes base

Configurar las actualizaciones automáticas de imágenes base para Cloud Run permite que Google aplique parches de seguridad al sistema operativo y a los componentes del entorno de ejecución del lenguaje de la imagen base automáticamente. No es necesario volver a compilar o volver a implementar el servicio para que se actualice la imagen base. No se crea una revisión nueva cuando se actualiza la imagen base.

Para obtener información sobre cómo configurar políticas de actualización de seguridad en funciones creadas con comandos de gcloud functions o la API de Cloud Functions v2, consulta Seguridad del entorno de ejecución.

En el siguiente diagrama, se muestra cómo el código y las dependencias de tu aplicación ("imagen de la app") se superponen sobre el entorno de ejecución del lenguaje, los paquetes del SO y el sistema operativo ("imagen base"). Google actualiza automáticamente los componentes de la imagen base.

Política de actualización de seguridad

• Actualizaciones automáticas: Las actualizaciones y los parches de seguridad del entorno de ejecución se publican en versiones nuevas de la imagen del entorno de ejecución. Después de un período de prueba de estabilidad y confiabilidad, el entorno de ejecución actualizado se implementa en todos los servicios, lo que da como resultado una actualización sin tiempo de inactividad. Para implementar correcciones de seguridad a nivel del lenguaje, es posible que debas volver a compilar funciones o servicios que usen lenguajes compilados, como Go o Java.

• Actualizaciones de implementación: Las actualizaciones y los parches de seguridad se aplican a los tiempos de ejecución solo cuando se implementan o vuelven a implementar servicios, a menos que se indique lo contrario. Las actualizaciones en la implementación están disponibles en las funciones de Cloud Run (1ª gen.) y funciones de Cloud Run.

De forma predeterminada, las actualizaciones de seguridad automáticas están habilitadas para las funciones implementadas con los siguientes métodos:

• gcloud functions
• API de Cloud Functions v2
• gcloud run con la marca --functions y la marca --base-image

Configura actualizaciones automáticas de imágenes base

Para configurar las actualizaciones automáticas de imágenes base, sigue estos pasos:

• Selecciona una imagen base compatible con Cloud Run.
• Compila y, luego, implementa la imagen de tu aplicación de forma que preserve la capacidad de cambiar la base de tu servicio en ejecución de forma segura.

Selecciona una imagen base

Una imagen base es el punto de partida para la mayoría de los flujos de trabajo de desarrollo basados en contenedores. Los desarrolladores comienzan con una imagen base y, sobre ella, colocan las bibliotecas, los objetos binarios y los archivos de configuración necesarios para ejecutar su aplicación.

Los paquetes de compilación de Google Cloud publican y mantienen imágenes base para compilar aplicaciones sin servidores. Estas imágenes base se basan en la distribución de Ubuntu de Linux.

Cloud Run solo admite imágenes base automáticas que usen imágenes base de paquetes de compilación de Google Cloud.

Debes tener en cuenta lo siguiente cuando elijas una imagen base de paquetes de compilación:

• Pila: Una pila se compone de una versión de distribución de Linux y paquetes del sistema, como OpenSSL y curl.
• Lenguaje: Es la versión específica del lenguaje de programación que usa tu aplicación.

Revisa las imágenes base del entorno de ejecución para obtener más información sobre las variaciones de las imágenes base.

Compila la imagen de la aplicación

Los servicios con actualizaciones automáticas habilitadas deberán proporcionar una imagen de aplicación que omita las capas base del sistema operativo. Existen dos maneras de hacerlo.

• Usa la función de implementación desde la fuente de Cloud Run (recomendado)
• Con un sistema de compilación, copia tu aplicación en una imagen de scratch

Implementa desde la fuente

Puedes usar la opción de implementación desde fuente de Cloud Run para compilar e implementar tu código de modo que tu servicio sea compatible con la recepción de actualizaciones automáticas. Para ello, debes proporcionar la marca --base-image cuando crees la aplicación.

Por ejemplo, para implementar un servicio de Node.js con las actualizaciones automáticas de la imagen base habilitadas, usa el siguiente comando:

gcloud run deploy \
    --source . \
    --base-image nodejs22 \
    --automatic-updates

Para implementar una función, debes especificar la marca --function con el punto de entrada de la función desde tu código fuente.

Build on scratch

También puedes usar tu cadena de herramientas de compilación para crear una imagen de contenedor de aplicación que sea compatible con las actualizaciones automáticas de imagen base.

Cuando implementas un servicio de Cloud Run con actualizaciones automáticas de imágenes base, la imagen de contenedor de tu aplicación se superpone sobre una imagen de contenedor base. La imagen de contenedor de la aplicación solo debe incluir tu aplicación, no el sistema operativo ni el tiempo de ejecución, que se proporcionan en la imagen de contenedor base.

Para crear la imagen del contenedor de la aplicación, haz lo siguiente:

1. Crea un Dockerfile de varias etapas que haga lo siguiente:
   1. Compila la aplicación con una imagen base adecuada con las dependencias necesarias.
   2. Copia los componentes compilados en una imagen inicial.
2. Compila la imagen del contenedor de la aplicación y envíala a Artifact Registry.
3. Implementa la imagen del contenedor de la aplicación en Cloud Run y especifica una imagen base.

Crea un Dockerfile de varias etapas

Para esta guía, usaremos una aplicación de Node.js. Esta guía no es específica del idioma y se puede personalizar para tu aplicación y tu idioma.

• Crea un Dockerfile en el directorio raíz de nuestro proyecto con el siguiente código:

  # This Dockerfile will produce an image that only includes the Node.js app and *not* the Node.js runtime.
  # The resulting image will not run locally. It is intended at being layered on top of a Node.js base image.
  
  FROM node:nodejs22-slim as builder
  
  # Create and change to the app directory.
  WORKDIR /usr/src/app
  
  # Copy application dependency manifests to the container image and install
  # production dependencies.
  COPY package*.json ./
  RUN npm install --only=production
  
  # Copy local code to the container image.
  COPY . ./
  
  # Copy the application source code and depenencies onto a scratch image.
  FROM scratch
  WORKDIR /workspace
  COPY --from=builder --chown=33:33 /usr/src/app/ ./
  
  # Run the web service on container startup.
  CMD [ "node", "index.js" ]
  

Este Dockerfile usa una compilación de varias etapas para copiar el código fuente de la aplicación y las dependencias en una imagen de scratch que omite el sistema operativo, los paquetes y los componentes del entorno de ejecución. que la imagen base administrada de Cloud Run proporcionará en el entorno de ejecución.

Compila la imagen de tu aplicación

Compila la imagen de tu aplicación y súbela a Artifact Registry. Consulta Compila contenedores para obtener detalles sobre cómo compilar un Dockerfile con Cloud Build y subirlo a Artifact Registry.

Implementa la imagen de la aplicación

Ya puedes implementar la imagen de tu aplicación con las actualizaciones automáticas habilitadas con la imagen base más compatible para tu aplicación. En el siguiente ejemplo, se usan el entorno de ejecución nodejs22 y la región europe-west1. Para obtener más información sobre las variaciones de las imágenes base, revisa las imágenes base del entorno de ejecución.

Consulta cómo implementar desde el código fuente para obtener más detalles sobre los roles y permisos necesarios.

resource "google_cloud_run_v2_service" "default" {
  provider = google-beta
  name     = "SERVICE"
  location = "REGION"

  template {
    containers {
      image = "IMAGE_URL"
      base_image_uri = "BASE_IMAGE"
    }
  }
}

Vuelve a ensamblar imágenes de contenedor para ejecutarlas de forma local

Las imágenes de contenedor de aplicaciones que se usan con las actualizaciones automáticas de imágenes base se compilan en scratch y no se pueden ejecutar fuera de Cloud Run con las actualizaciones de imágenes base habilitadas. Puedes hacer que la imagen de tu aplicación se pueda ejecutar si la rebasas sobre una imagen base compatible.

1. Instala la edición de la comunidad de Docker (CE) en tu estación de trabajo.

2. Descarga la imagen de la aplicación:

   docker pull APP_IMAGE
   

   Reemplaza APP_IMAGE por la URL de tu imagen de contenedor.

3. Descarga la imagen base:

   docker pull BASE_IMAGE
   

   Reemplaza BASE_IMAGE por la ruta de acceso completa a una imagen base compatible. Consulta las imágenes base de los paquetes de compilación de Google Cloud para obtener una lista de las imágenes base disponibles.

4. Vuelve a ensamblar la imagen:

   Usa un Dockerfile para copiar todos los archivos de la imagen de la app en la imagen base:

   ARG APP_IMAGE
   ARG NEW_BASE_IMAGE
   
   # first copy all files from the app image onto the builder image
   FROM ${APP_IMAGE} AS app
   FROM ${NEW_BASE_IMAGE} AS builder
   COPY --from=app / /
   
   # restore the app image config by copying everything from previous step back
   # back onto the app image
   FROM ${APP_IMAGE}
   COPY --from=builder / /
   

   Compila la imagen:

   docker build \
       -t IMAGE \
       --build-arg APP_IMAGE=APP_IMAGE \
       --build-arg NEW_BASE_IMAGE=BASE_IMAGE \
       .
   

   Reemplaza IMAGE por el nombre de la imagen reensamblada.

   Si ves advertencias que indican que ARG ${APP_IMAGE} y ARG ${NEW_BASE_IMAGE} no son imágenes base válidas, puedes ignorarlas y ejecutar la imagen:

   docker run -p 8080:8080 IMAGE
   

Inhabilita las actualizaciones automáticas

Cuando se implementa desde la fuente

Cuando implementas desde la fuente, puedes inhabilitar las actualizaciones automáticas de la imagen base con la marca --no-automatic-updates. En el siguiente ejemplo, se muestra cómo inhabilitar las actualizaciones automáticas de la imagen base para un servicio de Node.js:

gcloud run deploy SERVICE \
    --source . \
    --base-image nodejs22 \
    --no-automatic-updates

Cuando se implementa una imagen de contenedor

Para inhabilitar las actualizaciones de la imagen base de un servicio que usa una imagen de contenedor compilada en scratch, debes implementar una nueva imagen de contenedor que incluya la imagen base y quitar la imagen base:

Cómo ver la versión de la imagen base

Para ver la versión de la imagen base que se usa para entregar tu aplicación, consulta el recurso LogEntry.labels.run.googleapis.com/base_image_versions en los registros del servicio de Cloud Run.

Limitaciones conocidas

• Las actualizaciones automáticas de imágenes base solo admiten imágenes base de paquetes de compilación de Google Cloud. No es posible usar tus propias imágenes base.

• Las aplicaciones que usan lenguajes compilados no se volverán a compilar como resultado de una actualización automática de la imagen base.

• Es posible que los análisis de seguridad en la imagen de tu aplicación estén incompletos. Debido a que tu imagen de aplicación ahora se compila en scratch, los escáneres de seguridad solo analizarán la parte de la aplicación de tu imagen. Para obtener una imagen más completa de la seguridad de tu contenedor, también debes ejecutar análisis en la imagen base correspondiente que proporciona Google. Puedes descargar la imagen base y usar herramientas de código abierto para ejecutar un análisis.