Configura activaciones de volúmenes en memoria para servicios

En esta página, se describe cómo configurar un volumen en memoria dedicado que puedes usar para operaciones de lectura y escritura de archivos mediante activaciones de volúmenes de Cloud Run. Ten en cuenta que esta función difiere del sistema de archivos en memoria integrado que proporciona Cloud Run.

Cuando activas el volumen en memoria en Cloud Run, el volumen en memoria aparece como archivos en el sistema de archivos del contenedor. Después de activar el volumen en memoria, puedes acceder a él como si fuera un directorio en tu sistema de archivos local, mediante las operaciones y bibliotecas del sistema de archivos de tu lenguaje de programación.

Puedes usar volúmenes en memoria para hacer lo siguiente:

Limitar el tamaño del volumen en memoria. Cuando limitas el tamaño de un volumen, las operaciones de escritura en un volumen completo fallarán, lo que es preferible a que Cloud Run finalice las instancias debido a que el volumen consume demasiada memoria.
Compartir un volumen en memoria entre diferentes contenedores en una instancia de Cloud Run. Cuando Cloud Run escala horizontalmente a varias instancias de un servicio, cada instancia tiene su propio volumen en memoria compartido por todos los contenedores de esa instancia. Este volumen está disponible para todos los contenedores cuando Cloud Run escala horizontalmente a fin de controlar el tráfico.

Comportamiento

Cuando se crea un volumen en memoria, recomendamos especificar un límite de tamaño. Si el volumen alcanza su límite de tamaño, las escrituras adicionales fallarán con un error de memoria insuficiente. Tu instancia puede controlar este error y seguir ejecutándose.

Ten en cuenta que el límite de tamaño es solo un límite: no asigna espacio adicional para el volumen en memoria. En cambio, el volumen en memoria consume la memoria que configuraste para los contenedores. Si implementas varios contenedores, la memoria que usa cada operación de escritura en el volumen cuenta como uso de memoria para el contenedor que escribió los datos.

Si no especificas un límite de tamaño, se establece automáticamente como la mitad del tamaño total de todos los contenedores de tu trabajo o servicio. Por ejemplo, el tamaño de volumen emptyDir = [Memoria (Contenedor A) + Memoria (Contenedor B) + Memoria (Contenedor N)]/2. Este comportamiento predeterminado puede hacer que el límite de tamaño del volumen en memoria sea mayor que la memoria asignada para algunos de tus contenedores. En esta situación, si tu contenedor sigue escribiendo memoria en el volumen, superará su memoria asignada y fallará antes de que se alcance el límite de tamaño del volumen.

Aunque establecer un límite de tamaño es opcional, te recomendamos configurar uno para proteger a tus contenedores de la falta de memoria y fallas.

Rutas no permitidas

Cloud Run no te permite activar un volumen en /dev, /proc y /sys, ni en sus subdirectorios.

Configura un volumen en memoria

Cualquier cambio en la configuración conlleva la creación de una revisión nueva. Las revisiones posteriores también adoptarán esta configuración de manera automática, a menos que realices actualizaciones explícitas para cambiarla.

Después de configurar un volumen en memoria para el servicio de Cloud Run, se crea un volumen vacío para cada instancia de Cloud Run que se inicia, y el volumen existe mientras esa instancia esté en ejecución. Cuando la instancia deja de ejecutarse, los datos del volumen se borran de forma permanente.

Console

En la consola de Google Cloud ve a Cloud Run:

Ir a Cloud Run
Haz clic en Implementar contenedor y selecciona Servicio para configurar un servicio nuevo. Si quieres configurar un servicio existente, haz clic en el servicio y, luego, en implementar y editar la nueva revisión.
Si configuras un servicio nuevo, completa la página de configuración del servicio inicial como desees y haz clic en Contenedores, volúmenes, Herramientas de redes y seguridad para expandir la página de configuración del servicio.
Haz clic en la pestaña Volúmenes.
- En Volúmenes, haz lo siguiente:
  - Haz clic en Agregar volumen.
  - En el menú desplegable Tipo de volumen, selecciona En memoria como el tipo de volumen.
  - En el campo Nombre del volumen, ingresa el nombre que deseas usar para el volumen.
  - Haz clic en Listo.
- Haz clic en la pestaña Contenedor.
- Haz clic en la pestaña Activaciones de volúmenes.
Haz clic en Crear o Implementar.

gcloud

Para agregar un volumen y activarlo, sigue estos pasos:
```
gcloud beta run services update SERVICE \
--add-volume=name=VOLUME_NAME,type=in-memory,size-limit=SIZE_LIMIT \
--add-volume-mount=volume=VOLUME_NAME,mount-path=MOUNT_PATH
```
Reemplaza lo siguiente:
- SERVICE por el nombre de tu servicio
- VOLUME_NAME por el nombre que quieras para el volumen. El valor VOLUME_NAME se usa para asignar el volumen a la activación de volúmenes.
- MOUNT_PATH por la ruta de acceso relativa en el sistema de archivos del contenedor en el que deseas activar este volumen, por ejemplo, /mnt/my-volume
- SIZE_LIMIT por el límite de memoria que deseas asignar al volumen, en MiB o GiB (especificado como Mi o Gi), por ejemplo, 500Mi. Este límite debe ser menor que la memoria total especificada para tus contenedores.

Si usas varios contenedores, primero especifica los volúmenes y, luego, especifica las activaciones de volúmenes de cada contenedor:

gcloud beta run services update SERVICE \
--add-volume=name= VOLUME_NAME,type=in-memory,size-limit=SIZE_LIMIT \
--container=CONTAINER_1 \
--add-volume-mount=volume= VOLUME_NAME,mount-path=MOUNT_PATH \
--container==CONTAINER_2 \
--add-volume-mount=volume= VOLUME_NAME,mount-path=MOUNT_PATH2

YAML

Si creas un servicio nuevo, omite este paso. Si actualizas un servicio existente, descarga su configuración de YAML:
```
gcloud run services describe SERVICE --format export > service.yaml
```
Configura los atributos volumeMounts y volumes como se muestra a continuación:
```
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  annotations:
    run.googleapis.com/launch-stage: BETA
spec:
  template:
    spec:
      containers:
      - image: IMAGE_URL
        volumeMounts:
        - mountPath: MOUNT_PATH
          name: VOLUME_NAME
      volumes:
      - name: VOLUME_NAME
        emptyDir:
          sizeLimit: SIZE_LIMIT
          medium: Memory
```
Reemplaza lo siguiente:
- IMAGE_URL por una referencia a la imagen del contenedor, como us-docker.pkg.dev/cloudrun/container/hello:latest Si usas Artifact Registry, el repositorio REPO_NAME debe estar creado. La URL tiene el formato LOCATION-docker.pkg.dev/PROJECT_ID/REPO_NAME/PATH:TAG.
- VOLUME_NAME por el nombre que quieras para el volumen. El valor VOLUME_NAME se usa para asignar el volumen a la activación de volúmenes.
- MOUNT_PATH por la ruta de acceso relativa en el sistema de archivos del contenedor en el que deseas activar este volumen, por ejemplo, /mnt/my-volume
- SIZE_LIMIT por el límite de memoria que deseas asignar al volumen, en MiB o GiB (especificado como Mi o Gi), por ejemplo, 500Mi. Este límite debe ser menor que la memoria total especificada para tus contenedores.
Crea o actualiza el servicio con el siguiente comando:
```
gcloud run services replace service.yaml
```

Leer y escribir en un volumen

Si usas la función de activación de volúmenes de Cloud Run, accedes a un volumen activado con las mismas bibliotecas en tu lenguaje de programación que usas para leer y escribir archivos en tu sistema de archivos local.

Esto es muy útil si usas un contenedor existente que espera que los datos se almacenen en el sistema de archivos local y usa operaciones regulares del sistema de archivos para acceder a él.

En los siguientes fragmentos, se supone una activación de volumen con una mountPath configurada como /mnt/my-volume.

Nodejs

Usa el módulo del sistema de archivos para crear un archivo nuevo o agregarlo a uno existente en el volumen, /mnt/my-volume:

var fs = require('fs');
fs.appendFileSync('/mnt/my-volume/sample-logfile.txt', 'Hello logs!', { flag: 'a+' });

Python

Escribe en un archivo mantenido en el volumen, /mnt/my-volume:

f = open("/mnt/my-volume/sample-logfile.txt", "a")

Go

Usa el paquete os para crear un archivo nuevo mantenido en el volumen, /mnt/my-volume

f, err := os.Create("/mnt/my-volume/sample-logfile.txt")

Java

Usa la clase Java.io.File para crear un archivo de registro en el volumen, /mnt/my-volume:

import java.io.File;
File f = new File("/mnt/my-volume/sample-logfile.txt");