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.

En el siguiente diagrama, se muestra cómo el código y las dependencias de tu aplicación ("imagen de la app") se apilan 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.

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 los paquetes de compilación de Google Cloud:

• Pila: Una pila se compone de una versión de distribución de Linux y paquetes del sistema, como OpenSSL y curl.
• Lenguaje: 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 implementar 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 función implementar 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 o una función de Node.js con las actualizaciones automáticas de la imagen base habilitadas, usa el siguiente comando:

gcloud beta run deploy \
  --source . \
  --base-image nodejs20

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 coloca en capas sobre una imagen de contenedor base. La imagen del contenedor de la aplicación solo debe incluir tu aplicación, no el sistema operativo ni el entorno de ejecución, que se proporcionan en la imagen del 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 intented at being layered on top of a Node.js base image.
  
  FROM node:20-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 este ejemplo, usaremos el entorno de ejecución de Node.js 20 de us-central1. Revisa las imágenes base del entorno de ejecución para obtener más información sobre las variaciones de las imágenes base.

Consulta cómo implementar imágenes de contenedores en Cloud Run para obtener más detalles sobre los roles y permisos necesarios.

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. Para que tu imagen de aplicación se pueda ejecutar, debes cambiar su base a 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 lo siguiente:

   • APP_IMAGE por la URL de la imagen de contenedor

3. Descarga la imagen base:

   docker pull BASE_IMAGE
   

   Reemplaza lo siguiente:

   • BASE_IMAGE por la URL de una imagen base compatible. Puedes encontrar la lista de imágenes base disponibles en Imágenes base de paquetes de compilación de Google Cloud. Por ejemplo, si creaste una aplicación de Node.JS 20 con la pila google-22, seleccionarías us-central1-docker.pkg.dev/serverless-runtimes/google-22/runtimes/nodejs20:latest.

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 lo siguiente:

   • IMAGE por el nombre de la imagen que volviste a ensamblar.

   Si ves advertencias de 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 implementes desde la fuente, puedes inhabilitar las actualizaciones automáticas de las imágenes base con la marca --no-automatic-updates. En el siguiente ejemplo, se muestra cómo inhabilitar las actualizaciones automáticas de imágenes base para un servicio de Node.js:

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

Cuando implementes una imagen de contenedor

Para inhabilitar las actualizaciones de la imagen base de un servicio que usa una imagen de contenedor compilada desde cero, debes implementar una nueva imagen de contenedor que incluya la imagen base y quitarla:

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.