Aplicaciones sin servidor creadas con AWS Lambda ofrecen agilidad, escalabilidad y eficiencia, pero carecen de almacenamiento persistente integrado. Cuando las funciones Lambda necesitan acceder a archivos a través de invocaciones o compartir datos de forma persistente, Nube nativa Qumulo (CNQ) salva esta distancia.
Este blog muestra cómo conectar AWS Lambda a CNQ a través de NFS que permite el acceso persistente y escalable a archivos para sus aplicaciones sin servidor.
En este blog:
¿Qué es AWS Lambda?
Por qué AWS Lambda necesita almacenamiento persistente
Configuración del acceso CNQ NFS para Lambda
Creación de una función lambda que interactúa con CNQ
Empaquetado y despliegue de Lambda
Ponerlo todo a prueba
¿Qué es AWS Lambda?
AWS Lambda es un servicio informático sin servidor y basado en eventos que ejecuta su código en respuesta a eventos, como solicitudes HTTP, cargas de archivos o cambios en las transmisiones de datos, sin necesidad de aprovisionar o administrar servidores. Se encarga del escalado, el mantenimiento y el registro, para que usted pueda centrarse en escribir código en el lenguaje que prefiera. Las funciones sólo se ejecutan cuando se activan, y sólo se factura por el tiempo de computación utilizado.
Lambda es especialmente adecuado para escenarios que requieren un escalado rápido y un procesamiento basado en eventos:
Procesamiento de archivos: Activa flujos de trabajo en tiempo real al subir archivos a Amazon S3.
Procesamiento de flujos: Analice y procese datos de streaming en tiempo real procedentes de fuentes como Amazon Kinesis.
Aplicaciones web: Cree aplicaciones web escalables integrando Lambda con otros servicios de AWS.
Backends IoT: Gestione operaciones de backend para dispositivos IoT sin necesidad de gestionar servidores.
⚠️ Sin embargo, Lambda es apátrida por diseño. Las funciones no tienen almacenamiento persistente integrado, por lo que se necesitan soluciones externas para la persistencia de archivos.
Por qué AWS Lambda necesita almacenamiento persistente
La informática sin servidor ha cambiado el desarrollo de aplicaciones al permitir a los desarrolladores crear funciones altamente escalables sin necesidad de una infraestructura de servidor complicada. Aunque las funciones de Lambda interactúan de forma nativa con el almacenamiento de objetos, como Amazon S3, muchos escenarios del mundo real requieren acceder a sistemas de archivos tradicionales, ya sea para dar soporte a aplicaciones heredadas o para aprovechar las ventajas que ofrece el almacenamiento basado en archivos.
La opción de almacenamiento persistente integrada de Amazon, Elastic File System (EFS), carece de compatibilidad con el protocolo SMB, lo que limita su uso a flujos de trabajo heredados que dependen de NFS. Al integrar AWS Lambda con Cloud Native Qumulo (CNQ), los desarrolladores pueden salvar esta brecha sin problemas. Las capacidades multiprotocolo de CNQ permiten a las aplicaciones sin servidor acceder directamente a sistemas de archivos heredados sin comprometer la escalabilidad ni la simplicidad.
Con CNQ y AWS Lambda, los flujos de trabajo con estado se convierten en totalmente sin servidor, lo que ofrece una velocidad, facilidad de uso y potencia de almacenamiento sólidas inigualables, todo ello sin complejidad.
Muchas aplicaciones del mundo real necesitan un almacenamiento persistente de archivos:
Generar y guardar informes
Procesamiento de archivos cargados
Compartir datos entre invocaciones o servicios
El almacenamiento temporal /tmp de Lambda es efímero. CNQ ofrece almacenamiento NFS persistente, de alto rendimiento, multiprotocolo y escalable, lo que lo hace ideal para estos escenarios.
Configuración del acceso CNQ NFS para Lambda
Implemente CNQ en su VPC de AWS: Despliegue CNQ a través de la interfaz de usuario web o CLI de Qumulo en cuestión de minutos.
Implementación de Qumulo nativo de la nube en AWS con CloudFormation
Implementación de Qumulo nativo de la nube en AWS con Terraform
Crear una exportación NFS de Qumulo:
Utilice la interfaz de usuario, la API o la CLI de qq para crear una exportación para su caso de uso de Lambda.
Asegure su exportación NFS:
Tiene permisos de lectura/escritura
Es accesible dentro de la misma VPC/subred que Lambda
Permite conexiones de puerto no root (Lambda no se ejecuta como root)
Configure CNQ Security:
Garantice el acceso de entrada en el puerto 2049/tcp (NFS):
Añada NFS a las reglas de entrada del grupo de seguridad de la VPC, sustituyendo el CIDR que aparece a continuación por el intervalo CIDR real de su subred Lambda.
aws ec2 authorize-security-group-ingress \--group-id sg-0a1b2c3d4e5f6g7h8 \--protocol tcp \--port 2049 \--cidr 192.168.0.0/24
Creación del código de la función lambda
Crea un archivo handler en Python (por ejemplo, test_cnq_access.py) con el siguiente código.
Nota: Sustituye YOUR_CNQ_ADDRESS por el nombre DNS (o dirección IP) de tu cluster CNQ y YOUR_NFS_EXPORT por tu ruta de exportación NFS real (por ejemplo, lambda-data).
import osimport sysfrom datetime import datetimeimport libnfsos.environ['LD_LIBRARY_PATH'] = "/var/task/lib:/var/task/libnfs:" + os.environ.get('LD_LIBRARY_PATH', '')sys.path.append('/var/task')def handler(evento, contexto):pruebe:nfs = libnfs.NFS("nfs://SU_CNQ_ADDRESS/SU_NFS_EXPORT")excepto Excepción como e:devolver {"statusCode": 500, "body": "Error al conectar con la exportación NFS: " + str(e)}pruebe:timestamp = datetime.now().isoformat()message = f "¡Hola desde AWS Lambda a través de CNQ! - {timestamp}\n "f = nfs.open("/prueba-de-lambda.txt", "w+")f.write(message)f.close()excepto Excepción como e:devolver {"statusCode": 500, "body": "Error al escribir en el archivo: " + str(e)}pruebe:f = nfs.open("/prueba-de-lambda.txt", "r")contenido = f.read()devolver {"statusCode": 200, "body": contenido}excepto Excepción como e:devolver {"statusCode": 500, "body": "Error leyendo archivo: " + str(e)}
Empaquetado de la función lambda
Dado que AWS Lambda no puede montar FUSE ni utilizar montajes NFS a nivel de núcleo, empaquetamos la biblioteca compartida nativa libnfs junto con el código Python para utilizar una alternativa de espacio de usuario.
IMPORTANTE: Construir y probar en un entorno de Amazon Linux 2 para la compatibilidad.
Script de creación del paquete de despliegue - Cree un script de shell (o ejecute estos comandos paso a paso). Ajústelo según sea necesario para su entorno.
#!/bin/bash################################################################# AWS Lambda Deployment Package Creation Script# Ejecuta estos pasos en una máquina virtual o contenedor de Amazon Linux 2.################################################################BUILD_DIR="/home/ec2-user/build "echo "Creating package directories... "mkdir -p "$BUILD_DIR/package/lib "echo "Installing prerequisite packages..."sudo yum -y install python3.8 python38-devel gcc libnfs-develsudo amazon-linux-extras enable python3.8echo "Instalando libnfs usando pip3.8... "pip3.8 install libnfs --target ./cp -L /usr/lib64/libnfs.so package/lib/echo "Creating a libnfs symlink in package (needed at runtime)... "cd package/libln -sf libnfs.so libnfs.so.8cd $BUILD_DIRecho "Copying test_cnq_access.py Lambda handler script... "cp test_cnq_access.py package/echo "Zipping deployment package (function.zip)... "cd packagezip -r ../función.zip .
Configuración IAM
Cree una política de confianza (trust-policy.json):
{"Versión": "2012-10-17","Statement": [{"Efecto": "Permitir", "Principal": {"Servicio": "lambda.amazonaws.com"}, "Acción": "sts:AssumeRole"}]}
Cree y adjunte las políticas necesarias:
aws iam create-role \--role-name LambdaCNQExecutionRole \--assume-role-policy-document file://trust-policy.json \--description "Función de ejecución lambda para funciones CNQ "aws iam attach-role-policy \--role-name LambdaCNQExecutionRole \--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRoleaws iam attach-role-policy \--role-name LambdaCNQExecutionRole \--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole
Creación de la función lambda
Sustituya "123456789012" por el ID de su cuenta de AWS.
aws lambda create-función \--función-name cnq-nfs-lambda \--runtime python3.8 \--role arn:aws:iam::123456789012:role/LambdaCNQExecutionRole \--handler test_cnq_access.handler \--zip-file fileb://function.zip
Configuración de los ajustes de la VPC
Para permitir que su función Lambda acceda a los recursos de una VPC, actualice su configuración con los detalles de su subred y grupo de seguridad.
aws lambda update-función-configuraciónfunción-name cnq-nfs-lambda \--vpc-config '{"SubnetIds": ["subnet-0a1b2c3d", "subnet-4e5f6g7h"],"SecurityGroupIds": ["sg-0abc123def456ghi7"]}'
Opcional: Adjuntar políticas personalizadas adaptadas a su caso de uso
Si su función Lambda necesita acceder a servicios adicionales (como S3), cree una política personalizada. Por ejemplo:
{"Versión": "2012-10-17","Statement": [{"Sid": "AllowCloudWatchLogs", "Efecto": "Permitir", "Acción": ["logs:CreateLogGroup","logs:CreateLogStream","logs:PutLogEvents"],"Resource": "arn:aws:logs:*:*:*"},{"Sid": "AllowS3Access", "Effect": "Permitir", "Acción": ["s3:GetObject","s3:PutObject","s3:ListBucket"],"Resource": ["arn:aws:s3:::YOUR_BUCKET_NAME","arn:aws:s3:::YOUR_BUCKET_NAME/*"]}]}
Nota: Asegúrese de utilizar el principio de mínimo privilegio en producción.
Ponerlo a prueba
Con todo configurado, es hora de ver tu trabajo en acción:
Activa la función lambda:
aws lambda invoke \--función-name cnq-nfs-lambda \--payload '{}' \--cli-binary-format raw-en-base64-out \response.json
Verifique la función montando la exportación CNQ NFS en un sistema de prueba y visualizando el archivo:
$ sudo mkdir /mnt/test$ sudo mount -t nfs -o vers=3,tcp,nconnect=16 10.99.2.230:/lambdatest /mnt/test$ cat /mnt/test/testing-from-lambda.txt¡Hola desde AWS Lambda a través de CNQ! - 2025-04-03T21:01:21
Depuración: Si experimenta algún error, puede ver la salida con fines de depuración:
aws logs filter-log-events --log-group-name /aws/lambda/cnq-nfs-lambda --limit 5Por qué es importante
La integración de AWS Lambda con CNQ mejora las capacidades sin servidor, lo que permite flujos de trabajo sin estado y sin complejidad añadida. La compatibilidad multiprotocolo de CNQ desbloquea la compatibilidad con sistemas heredados y ofrece un almacenamiento de archivos sólido y escalable, rápido, sencillo y sin servidor.
¡Feliz codificación!