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 entre invocaciones o compartir datos de forma persistente, Qumulo nativo de la nube (CNQ) salva esta brecha.
Este blog demuestra cómo conectar AWS Lambda a CNQ a través de NFS, lo que permite un 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 NFS de CNQ para Lambda
- Creación de una función Lambda que interactúa con CNQ
- Empaquetado e implementación de Lambda
- Poniéndolo todo a prueba
¿Qué es AWS Lambda?
AWS Lambda es un servicio de computación sin servidor y basado en eventos que ejecuta su código en respuesta a eventos, como solicitudes HTTP, cargas de archivos o cambios en el flujo de datos, sin necesidad de aprovisionar ni administrar servidores. Gestiona el escalado, el mantenimiento y el registro, para que usted pueda centrarse en escribir código en su lenguaje preferido. Las funciones se ejecutan solo cuando se activan y se le factura únicamente por el tiempo de computación utilizado.
Lambda es especialmente adecuado para escenarios que requieren escalamiento rápido y procesamiento basado en eventos:
- Procesamiento de archivos: active flujos de trabajo en tiempo real al cargar archivos en Amazon S3.
- Procesamiento de transmisión: analice y procese datos de transmisión en tiempo real desde fuentes como Amazon Kinesis.
- Aplicaciones web: cree aplicaciones web escalables integrando Lambda con otros servicios de AWS.
- Backends de IoT: administre las operaciones de backend para dispositivos IoT sin administración de servidores.
⚠️ Sin embargo, Lambda es sin estado por diseño. Las funciones no tienen almacenamiento persistente integrado, por lo que se requieren soluciones externas para la persistencia de archivos.
Por qué AWS Lambda necesita almacenamiento persistente
La computación sin servidor ha transformado el desarrollo de aplicaciones al permitir a los desarrolladores crear funciones altamente escalables sin necesidad de una infraestructura de servidor compleja. Si bien las funciones Lambda interactúan de forma nativa con el almacenamiento de objetos, como Amazon S3, muchas situaciones reales requieren el acceso a sistemas de archivos tradicionales, ya sea para dar soporte a aplicaciones heredadas o para aprovechar las ventajas del 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 superar esta deficiencia sin problemas. Las capacidades multiprotocolo de CNQ permiten que las aplicaciones sin servidor accedan 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 vuelven completamente sin servidor, brindando velocidad inigualable, facilidad de uso y potencia de almacenamiento robusta, todo sin complejidad.
Muchas aplicaciones del mundo real necesitan almacenamiento de archivos persistente:
- Generar y guardar informes
- Procesando 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 NFS de CNQ para Lambda
Implementar CNQ en su VPC de AWS: Implemente CNQ a través de la interfaz de usuario web o CLI de Qumulo en minutos.
- Guía del administrador de Qumulo nativo de la nube en AWS
- Cómo funciona Qumulo nativo de la nube en AWS
- 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 qq para crear una exportación para su caso de uso de Lambda.
Asegúrese de que su exportación NFS:
- Tiene permisos de lectura y escritura.
- Es accesible dentro de la misma VPC/subred que Lambda
- Permite conexiones a puertos que no sean root (Lambda no se ejecuta como root)
Configurar la seguridad de CNQ:
Garantizar el acceso de entrada en el puerto 2049/tcp (NFS):
Agregue NFS a las reglas de ingreso del grupo de seguridad de VPC y reemplace el CIDR a continuación con el rango CIDR real de su subred Lambda.
aws ec2 autorizar-seguridad-grupo-ingreso \ --id-grupo sg-0a1b2c3d4e5f6g7h8 \ --protocolo tcp \ --puerto 2049 \ --cidr 192.168.0.0/24
Creación del código de la función Lambda
Cree un archivo de controlador de Python (por ejemplo, test_cnq_access.py) con el siguiente código.
Nota: reemplace YOUR_CNQ_ADDRESS con el nombre DNS (o dirección IP) de su clúster CNQ y YOUR_NFS_EXPORT con su ruta de exportación NFS real (por ejemplo, lambda-data).
importar sistema operativo importar sistema desde fecha y hora importar fecha y hora importar libnfs os.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): try: nfs = libnfs.NFS("nfs://SU_DIRECCIÓN_CNQ/SU_EXPORTACIÓN_NFS") excepto Excepción como e: return {"statusCode": 500, "body": "Error al conectarse a la exportación NFS: " + str(e)} try: timestamp = datetime.now().isoformat() message = f "¡Hola desde AWS Lambda a través de CNQ! - {timestamp}\n" f = nfs.open("/testing-from-lambda.txt", "w+") f.write(message) f.close() excepto Excepción como e: return {"statusCode": 500, "body": "Error al escribir en el archivo: " + str(e)} try: f = nfs.open("/testing-from-lambda.txt", "r") content = f.read() return {"statusCode": 200, "body": content} excepto Excepción como e: return {"statusCode": 500, "body": "Error al leer el archivo: " + str(e)}
Empaquetado de la función Lambda
Dado que AWS Lambda no puede montar FUSE ni usar montajes NFS a nivel de kernel, empaquetamos la biblioteca compartida nativa libnfs junto con el código Python para usar una alternativa de espacio de usuario.
IMPORTANTE: compile y pruebe en un entorno de Amazon Linux 2 para garantizar la compatibilidad.
Script de creación de paquetes de implementación: cree un script de shell (o ejecute estos comandos paso a paso). Adáptelo según sea necesario a su entorno.
#!/bin/bash ################################################################### # Script de creación de paquete de implementación de AWS Lambda # Ejecute estos pasos en una máquina virtual o un contenedor de Amazon Linux 2. ########################################################################### BUILD_DIR="/home/ec2-user/build" echo "Creando directorios de paquetes..." mkdir -p "$BUILD_DIR/package/lib" echo "Instalando paquetes de requisitos previos..." sudo yum -y install python3.8 python38-devel gcc libnfs-devel sudo amazon-linux-extras enable python3.8 echo "Instalando libnfs con pip3.8..." pip3.8 install libnfs --target ./package echo "Copiando la biblioteca compartida libnfs nativa AL2 en el paquete..." cp -L /usr/lib64/libnfs.so package/lib/ echo "Creando un enlace simbólico libnfs en el paquete (necesario en tiempo de ejecución)..." cd package/lib ln -sf libnfs.so libnfs.so.8 cd $BUILD_DIR echo "Copiando el script del controlador Lambda test_cnq_access.py..." cp test_cnq_access.py package/ echo "Comprimiendo el paquete de implementación (function.zip)..." cd package zip -r ../function.zip .
Configuración de IAM
Cree una política de confianza (trust-policy.json):
{ "Versión": "2012-10-17", "Declaración": [ { "Efecto": "Permitir", "Principal": { "Servicio": "lambda.amazonaws.com" }, "Acción": "sts:AssumeRole" } ] }
Crear y adjuntar las políticas requeridas:
aws iam create-role \ --role-name LambdaCNQExecutionRole \ --assume-role-policy-document file://trust-policy.json \ --description "Rol de ejecución de Lambda para funciones CNQ" aws iam attached-role-policy \ --role-name LambdaCNQExecutionRole \ --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole
Creación de la función Lambda
Reemplace “123456789012” con su ID de cuenta de AWS.
aws lambda create-function \ --nombre-función cnq-nfs-lambda \ --tiempo-de-ejecución python3.8 \ --role arn:aws:iam::123456789012:role/LambdaCNQExecutionRole \ --handler test_cnq_access.handler \ --archivo-zip fileb://función.zip
Configuración de los ajustes de VPC
Para permitir que su función Lambda acceda a los recursos en una VPC, actualice su configuración con los detalles de su subred y grupo de seguridad.
configuración de la función de actualización de aws lambda \ --nombre-función 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", "Declaración": [ { "Sid": "AllowCloudWatchLogs", "Efecto": "Permitir", "Acción": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Recurso": "arn:aws:logs:*:*:*" }, { "Sid": "AllowS3Access", "Efecto": "Permitir", "Acción": [ "s3:GetObject", "s3:PutObject", "s3:ListBucket" ], "Recurso": [ "arn:aws:s3:::NOMBRE_DE_SU_DEPÓSITO", "arn:aws:s3:::NOMBRE_DE_SU_DEPÓSITO/*" ] } ] }
Nota: asegúrese de utilizar el principio de mínimo privilegio en producción.
Poniéndolo a prueba
Con todo preparado, es hora de ver tu trabajo en acción:
Activar la función Lambda:
invocación de aws lambda \ --nombre-de-función cnq-nfs-lambda \ --carga-útil '{}' \ --cli-binary-format raw-in-base64-out \ respuesta.json
Verifique la función montando la exportación NFS de CNQ en un sistema de prueba y viendo 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 para fines de depuración:
Filtro de registros de AWS para eventos de registro --nombre-grupo-registro /aws/lambda/cnq-nfs-lambda --limit 5
¿Por qué este Matters
La integración de AWS Lambda con CNQ mejora las capacidades sin servidor, lo que permite flujos de trabajo con estado fluidos y sin complejidad adicional. La compatibilidad multiprotocolo de CNQ facilita la compatibilidad con sistemas heredados, ofreciendo un almacenamiento de archivos robusto y escalable: rápido, sencillo y sin servidor.
¡Feliz codificación!
