Implementa un proxy de almacenamiento en caché de NFS de espacio de kernel en Compute Engine

Last reviewed 2023-10-03 UTC

En este instructivo, se muestra cómo implementar, configurar y probar un proxy de almacenamiento en caché del sistema de archivos de red (NFS) de espacio de kernel basado en Linux en Compute Engine. La arquitectura que se describe en este instructivo está diseñada para una situación en la que los datos de solo lectura se sincronizan a nivel de bytes desde un servidor de archivos de origen NFS (como un servidor de archivos NFS local) a Google Cloud, o se sincronizan según demanda desde una fuente de información principal a varias réplicas de solo lectura

En este instructivo, se supone que estás familiarizado con los siguientes temas:

  • Compilación de versiones personalizadas del sistema operativo Linux
  • Instalación y configuración del software con secuencias de comandos de inicio en Compute Engine
  • Configuración y administración de un sistema de archivos NFS

Esta arquitectura no admite el bloqueo de archivos. La arquitectura es más adecuada para canalizaciones que usan nombres de archivo únicos a fin de hacer un seguimiento de las versiones de los archivos.

Arquitectura

La arquitectura de este instructivo tiene un daemon de NFS del espacio de kernel (KNFSD) que actúa como una caché y un proxy de NFS. Esta configuración permite que los nodos de procesamiento basado en la nube accedan al almacenamiento local rápido con la migración de datos cuando un cliente de NFS lo solicite. Los nodos de cliente de NFS escriben datos directamente en el servidor de archivos de origen de NFS mediante el almacenamiento en caché con método write-through. En el siguiente diagrama, se muestra esta arquitectura:

Arquitectura en la que se usa un proxy de KNFSD en Google Cloud.

En este instructivo, implementarás y probarás el sistema del proxy de KNFSD. Puedes crear y configurar un solo servidor NFS, un proxy de KNFSD único y un solo cliente de NFS en Google Cloud.

El sistema del proxy de KNFSD funciona mediante la activación de un volumen desde el servidor NFS y la reexportación de ese volumen. El cliente de NFS activa el volumen reexportado desde el proxy. Cuando un cliente de NFS solicita datos, el proxy de KNFSD comprueba sus diversas tablas de caché para determinar si los datos residen de forma local. Si los datos ya están en la caché, el proxy de KNFSD los entrega de inmediato. Si los datos solicitados no están en la caché, el proxy migra los datos, actualiza sus tablas de caché y, luego, entrega los datos. El proxy de KNFSD almacena en caché los datos y metadatos de archivos a nivel de bytes, por lo que solo los bytes que se usan se transfieren a medida que se solicitan.

El proxy de KNFSD tiene dos capas de caché: L1 y L2. L1 es la caché de bloque estándar del sistema operativo que reside en la RAM. Cuando el volumen de datos supera la memoria RAM disponible, la caché L2 se implementa mediante FS-Cache, un módulo de kernel de Linux que almacena datos en caché de forma local en el disco. En esta implementación, debes usar la SSD local como tu caché L2, aunque puedes configurar el sistema de varias maneras.

Para implementar la arquitectura de este instructivo, usa herramientas estándar de NFS, que son compatibles con las versiones 2, 3 y 4 de NFS.

Implementación de KNFSD en una arquitectura híbrida

En una arquitectura híbrida, los clientes de NFS que se ejecutan en Google Cloud solicitan datos cuando son necesarios. Estas solicitudes se realizan al proxy de KNFSD, que entrega datos desde su caché local si están presentes. Si los datos no están en la caché, el proxy administra la comunicación con los servidores locales. El sistema puede activar uno o múltiples servidores de origen de NFS. El proxy administra toda la comunicación y migración de datos necesarias a través de una VPN o una interconexión dedicada hacia los servidores de origen de NFS locales. En el siguiente diagrama, se muestra esta implementación de KNFSD en una arquitectura híbrida:

Arquitectura híbrida con una implementación de KNFSD.

La conectividad híbrida está fuera del alcance de este instructivo. A fin de obtener información sobre temas avanzados, como las consideraciones para implementar en una arquitectura híbrida, el escalamiento a fin de obtener un alto rendimiento y el uso de métricas y paneles a fin de solucionar problemas y ajustar, consultaTemas avanzados del flujo de trabajo.

Objetivos

  • Implementar y probar un sistema de proxy de KNFSD
  • Crear y configurar los siguientes componentes en Google Cloud:
    • Una imagen de disco personalizada
    • Un proxy de KNFSD
    • Un servidor NFS
    • Un cliente de NFS
  • Activar un proxy de NFS en un cliente de NFS
  • Copiar un archivo del servidor NFS a través del proxy de NFS al cliente de NFS

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Para el uso, considera los costos de salida de red para datos escritos desde Google Cloud al almacenamiento local y los costos de la conectividad híbrida.

Antes de comenzar

Para esta guía de referencia, necesitas un proyecto de Google Cloud. Puedes crear uno nuevo o seleccionar un proyecto que ya hayas creado:

  1. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  2. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  3. Habilita la API de Compute Engine.

    Habilita la API

  4. En la consola de Google Cloud, activa Cloud Shell.

    Activar Cloud Shell

  5. Autentica tu acceso en la terminal de Cloud Shell:

    gcloud auth application-default login

    La línea de comandos te guiará para que completes los pasos de autorización.

  6. Establece las variables de entorno:

    export GOOGLE_CLOUD_PROJECT=PROJECT_NAME
gcloud config set project $GOOGLE_CLOUD_PROJECT

    Reemplaza PROJECT_NAME por el nombre del proyecto que creaste o seleccionaste antes.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Descarga los archivos de configuración del instructivo

  1. En Cloud Shell, clona el repositorio de GitHub:

    cd ~/
git clone https://github.com/GoogleCloudPlatform/knfsd-cache-utils.git

  2. Configura la etiqueta de Git como una versión en buen estado conocida (en este caso, v0.9.0):

    cd ~/knfsd-cache-utils
git checkout tags/v0.9.0

  3. Navega al directorio image en tu repositorio de código:

     cd ~/knfsd-cache-utils/image

Configurar la red

Para simplificar la implementación, en este instructivo se usa la red de VPC predeterminada. A fin de que puedas usar SSH para conectarte a varios recursos con fines de configuración y supervisión, en este instructivo también se implementan direcciones IP externas.

Las prácticas recomendadas y las arquitecturas de referencia para el diseño de VPC están fuera del alcance de este instructivo. Sin embargo, si integras estos recursos en un entorno híbrido, te recomendamos que sigas las prácticas recomendadas, incluidas las siguientes:

Para configurar tu red, haz lo siguiente:

  • En Cloud Shell, configura las variables de entorno.

    export BUILD_MACHINE_NETWORK=default
export BUILD_MACHINE_SUBNET=default

Crea la máquina de compilación de proxy de NFS

En esta sección, crearás y accederás a una VM que actúe como tu máquina de compilación de proxy de NFS. Luego, ejecutarás una secuencia de comandos de instalación proporcionada a fin de actualizar las versiones de kernel y, después, instalarás todo el software necesario para el sistema del proxy de KNFSD. La secuencia de comandos de instalación del software puede tardar unos minutos en ejecutarse, pero solo tienes que ejecutarla una vez.

  1. En Cloud Shell, configura las variables de entorno.

    export BUILD_MACHINE_NAME=knfsd-build-machine
export BUILD_MACHINE_ZONE=us-central1-a
export IMAGE_FAMILY=knfsd-proxy
export IMAGE_NAME=knfsd-proxy-image

  2. Inicia la instancia de VM:

    gcloud compute instances create $BUILD_MACHINE_NAME \
  --zone=$BUILD_MACHINE_ZONE \
  --machine-type=n1-standard-16 \
  --project=$GOOGLE_CLOUD_PROJECT \
  --image=ubuntu-2004-focal-v20220615 \
  --image-project=ubuntu-os-cloud \
  --network=$BUILD_MACHINE_NETWORK \
  --subnet=$BUILD_MACHINE_SUBNET \
  --boot-disk-size=20GB \
  --boot-disk-type=pd-ssd \
  --metadata=serial-port-enable=TRUE

    Es posible que recibas un mensaje de advertencia que indica una discrepancia en el tamaño del disco. Puedes ignorar este mensaje.

  3. Crea un archivo tar del software que se debe instalar y, luego, cópialo en la máquina de compilación:

    tar -czf resources.tgz -C resources .
gcloud compute scp resources.tgz build@$BUILD_MACHINE_NAME: \
  --zone=$BUILD_MACHINE_ZONE \
  --project=$GOOGLE_CLOUD_PROJECT

  4. Después de que se inicie la VM, abre un túnel SSH hacia ella:

    gcloud compute ssh build@$BUILD_MACHINE_NAME \
  --zone=$BUILD_MACHINE_ZONE \
  --project=$GOOGLE_CLOUD_PROJECT

  5. Después de que se establezca el túnel SSH y tu línea de comandos se oriente a la instancia knfsd-build-machine, ejecuta la secuencia de comandos de instalación:

    tar -zxf resources.tgz
sudo bash scripts/1_build_image.sh

    La secuencia de comandos clona el repositorio de código del kernel de Ubuntu, actualiza la versión de kernel y, también, instala software adicional. Debido a que hay una clonación de repositorio involucrada, la secuencia de comandos puede tardar mucho tiempo en completarse.

  6. Una vez que finalice la secuencia de comandos de instalación y se muestre un mensaje de SUCCESS, reinicia la máquina de compilación:

    sudo reboot

    Cuando se reinicia la máquina de compilación, se muestran los siguientes mensajes:

    WARNING: Failed to send all data from [stdin]
ERROR: (gcloud.compute.ssh) [/usr/bin/ssh] exited with return code [255]

    Estos errores ocurren mientras Cloud Shell se revierte de tu máquina de compilación de proxy de NFS a tu máquina anfitrión. Puede pasar por alto estos errores.

  7. Después de que se reinicie la VM, vuelve a abrir un túnel SSH hacia ella:

    gcloud compute ssh $BUILD_MACHINE_NAME \
  --zone=$BUILD_MACHINE_ZONE \
  --project=$GOOGLE_CLOUD_PROJECT

  8. Una vez que se haya establecido el túnel SSH y tu línea de comandos esté orientada a la instancia de nfs-proxy-build, cambia a Root y verifica tu versión del SO:

    uname -r

    El resultado es similar al siguiente, lo que indica que las actualizaciones de software se realizaron de forma correcta:

    linux <$BUILD_MACHINE_NAME> 5.13.*-gcp ...

    Si el resultado no es similar al ejemplo anterior, vuelve a completar este proceso para volver a crear la máquina de compilación de proxy de NFS.

  9. Limpia el disco local y apaga la máquina de compilación:

    sudo bash /home/build/scripts/9_finalize.sh

    Se mostrarán las siguientes advertencias:

    userdel: user build is currently used by process 1431
userdel: build mail spool (/var/mail/build) not found

    Estas advertencias ocurren mientras Cloud Shell se revierte de tu máquina de compilación de proxy de NFS a tu máquina anfitrión. Puede pasar por alto estos errores.

Crea la imagen de disco personalizada

En esta sección, crearás una imagen personalizada a partir de la instancia. La imagen personalizada se almacena en un bucket de Cloud Storage multirregional que se encuentra en Estados Unidos.

  1. En Cloud Shell, configura las variables de entorno.

    export IMAGE_NAME=knfsd-image
export IMAGE_DESCRIPTION="first knfsd image from tutorial"
export IMAGE_LOCATION=us

  2. Crea la imagen de disco:

    gcloud compute images create $IMAGE_NAME \
  --project=$GOOGLE_CLOUD_PROJECT \
  --description="$IMAGE_DESCRIPTION" \
  --source-disk=$BUILD_MACHINE_NAME \
  --source-disk-zone=$BUILD_MACHINE_ZONE \
  --storage-location=$IMAGE_LOCATION

  3. Después de crear la imagen de disco, borra la instancia:

    gcloud compute instances delete $BUILD_MACHINE_NAME \
  --zone=$BUILD_MACHINE_ZONE

  4. Cuando se te solicite continuar, ingresa Y.

    Cuando borres la instancia de $BUILD_MACHINE_NAME, verás un mensaje que indica que se borrarán los discos conectado a la VM. Debido a que acabas de guardar una imagen personalizada, ya no necesitas este disco temporal y es seguro borrarlo.

Crea el servidor de origen de NFS

Como se mencionó antes, esta arquitectura está diseñada para conectar recursos basados en la nube a un servidor de archivos local. Para simplificar el proceso en este instructivo, debes crear un recurso de reemplazo que se ejecute en tu proyecto de Google Cloud a fin de simular esta conexión. Otorga el nombre nfs-server al recurso de reemplazo. La instalación y la configuración del software se encuentra en una secuencia de comandos de inicio. Para obtener más información, examina la secuencia de comandos, ~/knfsd-cache-utils/tutorial/nfs-server/1_build_nfs-server.sh.

  1. En Cloud Shell, ve al directorio de secuencias de comandos nfs-server descargadas:

    cd ~/knfsd-cache-utils/tutorial

  2. Crea tu servidor NFS de reemplazo:

    gcloud compute \
  --project=$GOOGLE_CLOUD_PROJECT instances create nfs-server \
  --zone=$BUILD_MACHINE_ZONE \
  --machine-type=n1-highcpu-2 \
  --maintenance-policy=MIGRATE \
  --image-family=ubuntu-2004-lts \
  --image-project=ubuntu-os-cloud \
  --boot-disk-size=100GB \
  --boot-disk-type=pd-standard \
  --boot-disk-device-name=nfs-server \
  --metadata-from-file startup-script=nfs-server-startup.sh

    Esta secuencia de comandos puede tardar unos minutos en completarse: Es posible que veas un mensaje de advertencia que indica que el tamaño del disco es inferior a 200 GB. Puedes ignorar esta advertencia.

Crea el proxy de NFS

En esta sección, crearás el proxy de NFS. Cuando se inicia el proxy, se configura el almacenamiento local, se preparan las opciones de activación para el servidor NFS y se exportan los resultados almacenados en caché. Una secuencia de comandos de inicio proporcionada organiza gran parte de este flujo de trabajo.

  1. En Cloud Shell, configura la siguiente variable:

    export PROXY_NAME=nfs-proxy

  2. Crea la VM nfs-proxy

    gcloud compute instances create $PROXY_NAME \
  --machine-type=n1-highmem-16 \
  --project=$GOOGLE_CLOUD_PROJECT \
  --maintenance-policy=MIGRATE \
  --zone=$BUILD_MACHINE_ZONE \
  --min-cpu-platform="Intel Skylake" \
  --image=$IMAGE_NAME \
  --image-project=$GOOGLE_CLOUD_PROJECT \
  --boot-disk-size=20GB \
  --boot-disk-type=pd-standard \
  --boot-disk-device-name=$PROXY_NAME \
  --local-ssd=interface=NVME \
  --local-ssd=interface=NVME \
  --local-ssd=interface=NVME \
  --local-ssd=interface=NVME \
  --metadata-from-file startup-script=proxy-startup.sh

    Es posible que veas un mensaje de advertencia que indica que el tamaño del disco es inferior a 200 GB. Puedes ignorar esta advertencia.

    La secuencia de comandos de inicio configura los comandos de activación de NFS y te permite ajustar el sistema. La configuración de la versión de NFS, sincronización o asíncrona, nocto y actimeo son algunas de las variables que es posible que quieras optimizar mediante la secuencia de comandos de inicio. Para obtener más información sobre esta configuración, consulta Optimiza tu sistema de archivos NFS.

    Con el comando de este paso, se define la marca --metadata-from-file, que inserta la secuencia de comandos de inicio en la plantilla de imagen. En este instructivo, usarás una secuencia de comandos proxy-startup.sh simple. La secuencia de comandos incluye algunas variables predefinidas y no incluye muchas opciones que puedes usar si te integras a tu canalización. Para ver casos de uso más avanzados, consulta el repositorio de GitHub knfsd-cache-utils.

Crea el cliente de NFS

En este paso, debes crear un solo cliente de NFS (llamado nfs-client) que represente el grupo de instancias administrado (MIG) que probablemente es a gran escala.

  • En Cloud Shell, crea tu cliente de NFS:

    gcloud compute \
  --project=$GOOGLE_CLOUD_PROJECT instances create nfs-client \
  --zone=$BUILD_MACHINE_ZONE \
  --machine-type=n1-highcpu-8 \
  --network-tier=PREMIUM \
  --maintenance-policy=MIGRATE \
  --image-family=ubuntu-2004-lts \
  --image-project=ubuntu-os-cloud \
  --boot-disk-size=10GB \
  --boot-disk-type=pd-standard \
  --boot-disk-device-name=nfs-client

    Es posible que veas un mensaje de advertencia que indica que el tamaño del disco es inferior a 200 GB. Puedes ignorar esta advertencia.

Activa el proxy de NFS en el cliente de NFS

En este paso, debes abrir una sesión SSH separada en el cliente de NFS y, luego, activar el proxy de NFS. Usa la misma shell para probar el sistema en la siguiente sección.

  1. En la consola de Google Cloud, ve a la página Instancias de VM.

    Ir a Instancias de VM

  2. Para conectarte a nfs-client, en la columna Conectar, haz clic en SSH.

  3. En la ventana SSH de nfs-client, instala las herramientas de NFS necesarias en nfs-client:

    sudo apt-get install nfs-common -y

  4. Crea un punto de activación y activa el proxy de NFS:

    sudo mkdir /data
sudo mount -t nfs -o vers=3 nfs-proxy:/data /data

Prueba el sistema

Ya se crearon todos tus recursos. En esta sección, ejecutarás una prueba copiando un archivo del servidor NFS a través del proxy de NFS al cliente de NFS. La primera vez que ejecutes esta prueba, los datos provendrán del servidor de origen. Esto puede tardar más de un minuto.

La segunda vez que ejecutes esta prueba, los datos se entregarán desde una caché que se almacena en las SSD locales del proxy de NFS. En esta transferencia, lleva mucho menos tiempo copiar los datos, lo que valida que el almacenamiento en caché acelera la transferencia de datos.

  1. En la ventana SSH de nfs-client que abriste en la sección anterior, copia el archivo test y visualiza el resultado correspondiente:

    time dd if=/data/test.data of=/dev/null iflag=direct bs=1M status=progress

    El resultado es similar al siguiente, que contiene una línea que muestra el tamaño del archivo, el tiempo de transferencia y las velocidades de transferencia:

    10737418240 bytes (11 GB, 10 GiB) copied, 88.5224 s, 121 MB/s
real    1m28.533s

    En esta transferencia, el archivo se entrega desde el disco persistente del servidor NFS, por lo que está limitado por la velocidad del disco del servidor NFS.

  2. Ejecuta el mismo comando por segunda vez:

    time dd if=/data/test.data of=/dev/null iflag=direct bs=1M status=progress

    El resultado es similar al siguiente, que contiene una línea que muestra el tamaño del archivo, el tiempo de transferencia y las velocidades de transferencia:

    10737418240 bytes (11 GB, 10 GiB) copied, 9.41952 s, 948 MB/s
real    0m9.423s

    En esta transferencia, el archivo se entrega desde la caché en el proxy de NFS, por lo que se completa más rápido.

Ya completaste la implementación y las pruebas del proxy de almacenamiento en caché de KNFSD.

Temas avanzados del flujo de trabajo

En esta sección, se incluye información sobre la implementación en una arquitectura híbrida, el escalamiento para obtener un alto rendimiento y el uso de métricas y paneles a fin de solucionar problemas y ajustar.

Características de rendimiento y tamaño de los recursos

Como se señaló antes, en este instructivo se usa un solo proxy de KNFSD. Por lo tanto, el escalamiento del sistema implica modificar los recursos de proxy individuales para optimizar la CPU, la RAM, las herramientas de redes, la capacidad de almacenamiento o el rendimiento. En este instructivo, implementaste KNFSD en una sola VM de Compute Engine con las siguientes opciones:

  • 16 CPU virtuales, 104 GB de RAM (n1-highmem-16).
    • Con 16 CPU virtuales y una arquitectura de Sandy Bridge o más reciente, habilitas una velocidad de red máxima de 32 Gbps.
  • Disco persistente de 10 GB como disco de arranque.
  • 4 discos SSD locales. Esta configuración proporciona un sistema de archivos de alta velocidad de 1.5 TB.

Aunque está fuera del alcance de este instructivo, puedes escalar esta arquitectura mediante la creación de varios proxies de KNFSD en un MIG y mediante un balanceador de cargas TCP para administrar las conexiones entre los clientes de NFS y los proxies de NFS Para obtener más información, consulta el repositorio de GitHub knfsd-cache-utils, que contiene secuencias de comandos de Terraform, código de ejemplo para la implementación y varias preguntas frecuentes sobre el escalamiento de las cargas de trabajo.

Consideraciones para una implementación híbrida

En muchas implementaciones, el ancho de banda de tu conexión desde el entorno local a la nube es un factor importante que debes tener en cuenta cuando configuras el sistema. La conectividad híbrida está fuera del alcance de este instructivo. Para obtener una descripción general de las opciones disponibles, consulta la documentación sobre la conectividad híbrida. Para obtener orientación sobre las prácticas recomendadas y los patrones de diseño, consulta la serie Compila arquitecturas de nubes híbridas y múltiples mediante Google Cloud.

Explora métricas

Los paneles pueden ser útiles para proporcionar comentarios sobre las métricas que se usarán en el ajuste del rendimiento y la solución de problemas generales. La exploración de las métricas está fuera del alcance de este instructivo. Sin embargo, hay un panel de métricas disponible cuando implementas el sistema de múltiples nodos que se define en el repositorio de GitHub knfsd-cache-utils

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

  1. En la consola de Google Cloud, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?