Usa sistemas de archivos de red

En este documento, se describe cómo usar los sistemas de archivos de red NFS, NDB, 9P, CIFS/Samba y Ceph con Cloud Run. Si usas Filestore o Cloud Storage FUSE en Cloud Run, consulta los instructivos de extremo a extremo para Filestore en Cloud Run o Cloud Storage FUSE en Cloud Run. Puedes usar un sistema de archivos de red para compartir y conservar datos entre varios contenedores y servicios en Cloud Run. Esta función solo está disponible si usas el entorno de ejecución de segunda generación de Cloud Run.

Si necesitas leer y escribir archivos en el servicio de Cloud Run con un sistema de archivos, tienes varias opciones:

  • Si no necesitas conservar los datos más allá de la vida útil de la instancia, puedes usar el sistema de archivos de memoria integrado.
  • Si necesitas conservar datos más allá de la vida útil de la instancia de contenedor y deseas usar la semántica del sistema de archivos estándar, usa un sistema de archivos de red como se describe en esta página. Puedes usar Filestore o sistemas de archivos de red autoadministrados, NFS, NDB, 9P, CIFS/Samba y Ceph con Cloud Run.
  • Si necesitas acceder a Cloud Storage como si fuera un sistema de archivos sin tener que ejecutar uno, usa Cloud Storage FUSE.
  • Si necesitas conservar datos aparte de la vida útil de la instancia de contenedor y no necesitas la semántica del sistema de archivos estándar, la opción más simple es usar las bibliotecas cliente de Cloud Storage. Esta también es una buena opción si necesitas acceder a los datos de muchas instancias al mismo tiempo.

Costos asociados con uso de sistemas de archivos de red

Los costos por usar un sistema de archivos de red se limitan al costo del sistema de archivos de red, según el lugar en el que se ejecuta el sistema de archivos y al costo habitual de ejecutar un servicio de Cloud Run. Para obtener un análisis de estos costos, consulta la explicación de costos en el instructivo de Filestore o Cloud Storage FUSE .

Limitaciones

Las siguientes consideraciones se aplican al uso de sistemas de archivos de red en Cloud Run:

  • Debes especificar el entorno de ejecución de segunda generación cuando realices la implementación en Cloud Run.

  • Cloud Run está diseñado para escalar con rapidez a una gran cantidad de instancias. Sin embargo, la mayoría de los sistemas de archivos de red no están diseñados para su uso simultáneo por una gran cantidad de clientes. Considera usar la función de cantidad máxima de instancias para limitar la cantidad de instancias de Cloud Run.

  • Cloud Run no admite el bloqueo de NFS, por lo que debes usar la opción -o nolock cuando actives NFS. Google recomienda diseñar tu aplicación para evitar escrituras simultáneas en la misma ubicación de archivo. Una forma de hacerlo es usar un sistema diferente, como Redis o Memorystore, para almacenar una exclusión mutua.

Configura un sistema de archivos de red

Si aún no tienes configurado un servidor de archivos, sigue la guía de soluciones de Servidores de archivos en Compute Engine a fin de seleccionar y configurar el sistema de archivos adecuado para tus necesidades. Si usas un servidor de archivos existente, asegúrate de que se pueda acceder a él desde una red de VPC.

Configura un conector de Acceso a VPC sin servidores

Debes usar el conector de acceso a VPC sin servidores para conectar el servicio de Cloud Run a la red de VPC en la que se ejecuta el sistema de archivos de red.

A fin de crear un conector de Acceso a VPC sin servidores en la misma red de VPC para conectarte al servicio de Cloud Run, sigue las instrucciones de la página Conéctate a una red de VPC.

Activa el sistema de archivos desde tu servicio de Cloud Run

Activar un sistema de archivos desde un servicio de Cloud Run es un tema avanzado. Puedes beneficiarte de revisar uno de los instructivos de extremo a extremo para usar Filestore o Cloud Storage FUSE.

Para activar un sistema de archivos de red:

  1. Define una secuencia de comandos de inicio que inicie la aplicación y especifique el punto de activación del Dockerfile. En el siguiente ejemplo, se muestra una secuencia de comandos que usa Filestore como el sistema de archivos de red:

    Python

    set -eo pipefail
    
    # Create mount directory for service.
    mkdir -p $MNT_DIR
    
    echo "Mounting Cloud Filestore."
    mount -o nolock $FILESTORE_IP_ADDRESS:/$FILE_SHARE_NAME $MNT_DIR
    echo "Mounting completed."
    
    # Run the web service on container startup. Here we use the gunicorn
    # webserver, with one worker process and 8 threads.
    # For environments with multiple CPU cores, increase the number of workers
    # to be equal to the cores available.
    # Timeout is set to 0 to disable the timeouts of the workers to allow Cloud Run to handle instance scaling.
    exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app
    
    # Exit immediately when one of the background processes terminate.
    wait -n

    Java

    set -eo pipefail
    
    # Create mount directory for service
    mkdir -p $MNT_DIR
    
    echo "Mounting Cloud Filestore."
    mount -o nolock $FILESTORE_IP_ADDRESS:/$FILE_SHARE_NAME $MNT_DIR
    echo "Mounting completed."
    
    # Start the application
    java -jar filesystem.jar
    
    # Exit immediately when one of the background processes terminate.
    wait -n

  2. Reemplaza el código de activación de archivo en la secuencia de comandos de inicio run.sh con los siguientes ejemplos y reemplaza las variables según sea necesario:

    • Para NFS

       echo "mounting NFSv4 share"
       mount -t nfs4 -o nolock IP_ADDRESS:FILE_SHARE_NAME MOUNT_POINT_DIRECTORY

      Asegúrate de usar la opción -o nolock cuando actives NFS. Cloud Run no admite el bloqueo de NFS.

    • Para NBD

       echo "mounting ext4 image via NBD"
       nbd-client -L -name image IP_ADDRESS DEVICE_NAME
       mount DEVICE_NAME MOUNT_POINT_DIRECTORY

    • Para PD-SSD a través de NBD

       echo "mounting PD-SSD via NBD"
       nbd-client -L -name disk IP_ADDRESS DEVICE_NAME
       mount DEVICE_NAME MOUNT_POINT_DIRECTORY

    • Para 9P

       echo "mounting 9p export"
       mount -t 9p -o trans=tcp,aname=/mnt/diod,version=9p2000.L,uname=root,access=user IP_ADDRESS MOUNT_POINT_DIRECTORY

    • Para SMB

       echo "mounting SMB public share"
       mount -t cifs -ousername=USERNAME,password=PASSWORD,ip=IP_ADDRESS //FILESHARE_NAME MOUNT_POINT_DIRECTORY
       echo "mounts completed"

  3. Define la configuración del entorno con el Dockerfile Usarás RUN a fin de especificar cualquier paquete del sistema adicional necesario, como nbd-client para NBD. Usa CMD a fin de especificar el comando que se ejecutará cuando se ejecute la imagen (la secuencia de comandos de inicio run.sh) y proporciona argumentos predeterminados para ENTRYPOINT, que especifica el objeto binario del proceso init.

    El siguiente es un Dockerfile de muestra para un servicio que usa Filestore:

    Python

    # Use the official lightweight Python image.
    # https://hub.docker.com/_/python
    FROM python:3.9-slim
    
    # Install system dependencies
    RUN apt-get update -y && apt-get install -y \
        tini \
        nfs-common \
        && apt-get clean
    
    # Set fallback mount directory
    ENV MNT_DIR /mnt/nfs/filestore
    
    # Copy local code to the container image.
    ENV APP_HOME /app
    WORKDIR $APP_HOME
    COPY . ./
    
    # Install production dependencies.
    RUN pip install -r requirements.txt
    
    # Ensure the script is executable
    RUN chmod +x /app/run.sh
    
    # Use tini to manage zombie processes and signal forwarding
    # https://github.com/krallin/tini
    ENTRYPOINT ["/usr/bin/tini", "--"]
    
    # Pass the startup script as arguments to tini
    CMD ["/app/run.sh"]

    Java

    
    # Use the official maven/Java 11 image to create a build artifact.
    # https://hub.docker.com/_/maven
    FROM maven:3.8.4-jdk-11 as builder
    
    # Copy local code to the container image.
    WORKDIR /app
    COPY pom.xml .
    COPY src ./src
    
    # Build a release artifact.
    RUN mvn package -DskipTests
    
    # Use AdoptOpenJDK for base image.
    # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
    FROM eclipse-temurin:17-jdk
    
    # Install filesystem dependencies
    RUN apt-get update -y && apt-get install -y \
        tini \
        nfs-kernel-server \
        nfs-common \
        && apt-get clean
    
    # Set fallback mount directory
    ENV MNT_DIR /mnt/nfs/filestore
    
    # Copy the jar to the production image from the builder stage.
    COPY --from=builder /app/target/filesystem-*.jar /filesystem.jar
    
    # Copy the statup script
    COPY run.sh ./run.sh
    RUN chmod +x ./run.sh
    
    # Use tini to manage zombie processes and signal forwarding
    # https://github.com/krallin/tini
    ENTRYPOINT ["/usr/bin/tini", "--"]
    
    # Run the web service on container startup.
    CMD ["/run.sh"]

Accede a un sistema de archivos de red desde el código de servicio de Cloud Run

Para acceder a los sistemas de archivos de red en el código de servicio, usa las operaciones de lectura y escritura de archivos como lo haces normalmente.

Implementa y organiza en contenedores

Cuando se complete el código de servicio de Cloud Run, aloja en contenedores e implementa como sueles hacer en un servicio de Cloud Run, asegúrate de especificar el entorno de ejecución de segunda generación.

¿Qué sigue?