Les applications sans serveur construites avec AWS Lambda offrent agilité, évolutivité et efficacité, mais elles ne disposent pas d'un stockage persistant intégré. Lorsque les fonctions Lambda ont besoin d'accéder à des fichiers à travers les invocations ou de partager des données de manière persistante, Cloud Native Qumulo (CNQ) comble cette lacune.
Ce blog montre comment connecter AWS Lambda à CNQ par l'intermédiaire de NFS, permettant un accès aux fichiers persistant et évolutif pour vos applications sans serveur.
Dans ce blog :
Qu'est-ce que AWS Lambda ?
Pourquoi AWS Lambda a besoin d'un stockage persistant
Configuration de l'accès CNQ NFS pour Lambda
Création d'une fonction Lambda qui interagit avec CNQ
Emballage et déploiement de la solution Lambda
Tout mettre à l'épreuve
Qu'est-ce que AWS Lambda ?
AWS Lambda est un service de calcul événementiel sans serveur qui exécute votre code en réponse à des événements, tels que des requêtes HTTP, des téléchargements de fichiers ou des modifications de flux de données, sans qu'il soit nécessaire de provisionner ou de gérer des serveurs. Il gère la mise à l'échelle, la maintenance et la journalisation, afin que vous puissiez vous concentrer sur l'écriture de code dans le langage de votre choix. Les fonctions ne s'exécutent que lorsqu'elles sont déclenchées, et vous n'êtes facturé que pour le temps de calcul utilisé.
Lambda est particulièrement bien adapté aux scénarios nécessitant une mise à l'échelle rapide et un traitement basé sur les événements :
Traitement des fichiers : Déclencher des flux de travail en temps réel lors du téléchargement de fichiers sur Amazon S3.
Traitement des flux : Analyse et traitement de données en flux continu en temps réel à partir de sources telles qu'Amazon Kinesis.
Applications Web : Créez des applications web évolutives en intégrant Lambda à d'autres services AWS.
Backends IoT : Gérez les opérations de backend pour les appareils IoT sans avoir à gérer de serveur.
⚠️ Cependant, Lambda est sans état par conception. Les fonctions n'ont pas de stockage persistant intégré, ce qui rend les solutions externes nécessaires pour la persistance des fichiers.
Pourquoi AWS Lambda a besoin d'un stockage persistant
L'informatique sans serveur a changé le développement d'applications en permettant aux développeurs de construire des fonctions hautement évolutives sans avoir besoin d'une infrastructure de serveur compliquée. Alors que les fonctions Lambda interagissent nativement avec le stockage d'objets, comme Amazon S3, de nombreux scénarios du monde réel nécessitent d'accéder aux systèmes de fichiers traditionnels, que ce soit pour prendre en charge des applications héritées ou pour tirer parti des avantages qu'offre le stockage basé sur les fichiers.
L'option de stockage persistant intégrée d'Amazon, Elastic File System (EFS), ne prend pas en charge le protocole SMB, ce qui limite son utilisation aux flux de travail existants qui reposent sur NFS. En intégrant AWS Lambda avec Cloud Native Qumulo (CNQ), les développeurs peuvent combler cette lacune de manière transparente. Les capacités multiprotocoles de CNQ permettent aux applications sans serveur d'accéder directement aux systèmes de fichiers hérités sans compromettre l'évolutivité ou la simplicité.
Avec CNQ et AWS Lambda, les workflows avec état deviennent entièrement sans serveur, offrant une vitesse inégalée, une facilité d'utilisation et une puissance de stockage robuste, le tout sans complexité.
De nombreuses applications réelles nécessitent un stockage permanent des fichiers :
Générer et sauvegarder des rapports
Traitement des fichiers téléchargés
Partage de données entre invocations ou services
Le stockage temporaire /tmp de Lambda est éphémère. CNQ offre un stockage NFS persistant, performant, multi-protocole et évolutif, ce qui le rend idéal pour ces scénarios.
Configuration de l'accès CNQ NFS pour Lambda
Déployer CNQ dans votre VPC AWS : Déployer CNQ via l'interface Web Qumulo ou le CLI en quelques minutes.
Créer un export Qumulo NFS :
Utilisez l'interface utilisateur, l'API ou le CLI qq pour créer une exportation pour votre cas d'utilisation Lambda.
Assurez votre exportation NFS :
A des permissions de lecture/écriture
Est accessible dans le même VPC/sous-réseau que Lambda
Permet des connexions portuaires non root (Lambda ne s'exécute pas en tant que root)
Configurer la sécurité CNQ :
Assurer un accès entrant sur le port 2049/tcp (NFS) :
Ajoutez NFS aux règles d'entrée du groupe de sécurité VPC, en remplaçant le CIDR ci-dessous par la plage CIDR réelle de votre sous-réseau Lambda.
aws ec2 authorize-security-group-ingress \--group-id sg-0a1b2c3d4e5f6g7h8 \--protocol tcp \--port 2049 \--cidr 192.168.0.0/24
Création du code de la fonction Lambda
Créez un fichier de gestion Python (par exemple, test_cnq_access.py) avec le code suivant.
Remarque : remplacez YOUR_CNQ_ADDRESS par le nom DNS (ou l'adresse IP) de votre cluster CNQ et YOUR_NFS_EXPORT par votre chemin d'exportation NFS (par exemple, 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')déf handler(event, context) :essayer:nfs = libnfs.NFS("nfs://Votre_adresse_CNQ/Votre_NFS_EXPORT")sauf Exception comme e :retour {"statusCode" : 500, "body" : "Erreur de connexion à l'exportation NFS : " + str(e)}essayer:timestamp = datetime.now().isoformat()message = f "Bonjour depuis AWS Lambda via CNQ ! - {timestamp}\n "f = nfs.open("/testing-from-lambda.txt", "w+")f.write(message)f.close()sauf Exception comme e :retour {"statusCode" : 500, "body" : "Erreur d'écriture dans le fichier : " + str(e)}essayer:f = nfs.open("/testing-from-lambda.txt", "r")content = f.read()retour {"statusCode" : 200, "body" : content}sauf Exception comme e :retour {"statusCode" : 500, "body" : "Erreur de lecture du fichier : " + str(e)}
Emballage de la fonction Lambda
Comme AWS Lambda ne peut pas monter FUSE ou utiliser des montages NFS au niveau du noyau, nous empaquetons la bibliothèque partagée native libnfs avec le code Python pour utiliser une alternative en espace utilisateur.
IMPORTANT : Construire et tester dans un environnement Amazon Linux 2 pour assurer la compatibilité.
Script de création de paquets de déploiement - Créez un script shell (ou exécutez ces commandes étape par étape). Adaptez-le à votre environnement.
#!/bin/bash################################################################# Script de création de paquets pour le déploiement AWS Lambda# Exécutez ces étapes sur une VM ou un conteneur 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 "Installing libnfs using pip3.8... "pip3.8 install libnfs --target ./packageecho "Copie de la bibliothèque partagée native AL2 libnfs dans le paquet... "cp -L /usr/lib64/libnfs.so package/lib/echo "Création d'un lien symbolique libnfs dans le paquet (nécessaire à l'exécution)... "cd package/libln -sf libnfs.so libnfs.so.8cd $BUILD_DIRecho "Copier test_cnq_access.py Lambda handler script... "cp test_cnq_access.py package/echo "Zipper le paquet de déploiement (function.zip)... "cd packagezip -r ../fonction.zip .
Configuration IAM
Créer une politique de confiance (trust-policy.json) :
{"Version" : "2012-10-17","Statement": [{"Effect" : "Allow", "Principal" : {"Service" : "lambda.amazonaws.com"}, "Action" : "sts:AssumeRole"}]}}
Créer et joindre les politiques nécessaires :
aws iam create-role \--role-name LambdaCNQExecutionRole \--assume-role-policy-document file://trust-policy.json \--description "Lambda execution role for CNQ functions "aws iam attach-role-policy \--role-name LambdaCNQExecutionRole \--policy-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
Création de la fonction Lambda
Remplacez "123456789012" par votre identifiant de compte AWS.
aws lambda create-fonction \--fonction-name cnq-nfs-lambda \--runtime python3.8 \--role arn:aws:iam::123456789012:role/LambdaCNQExecutionRole \--handler test_cnq_access.handler \--zip-file fileb://function.zip
Configuration des paramètres VPC
Pour permettre à votre fonction Lambda d'accéder aux ressources d'un VPC, mettez à jour sa configuration avec les détails de votre sous-réseau et de votre groupe de sécurité.
aws lambda update-fonction-configuration \N-fonction-name cnq-nfs-lambda \--vpc-config '{"SubnetIds" : ["subnet-0a1b2c3d", "subnet-4e5f6g7h"],"SecurityGroupIds": ["sg-0abc123def456ghi7"]}'
Facultatif : Attacher des politiques personnalisées adaptées à votre cas d'utilisation
Si votre fonction Lambda doit accéder à des services supplémentaires (comme S3), créez une politique personnalisée. Par exemple :
{"Version" : "2012-10-17","Statement": [{"Sid" : "AllowCloudWatchLogs", "Effect" : "Allow", "Action" : ["logs:CreateLogGroup","logs:CreateLogStream","logs:PutLogEvents"],"Resource": "arn:aws:logs:*:*:*"},{"Sid": "AllowS3Access", "Effect" : "Allow", "Action" : ["s3:GetObject","s3:PutObject","s3:ListBucket"],"Resource": ["arn:aws:s3:::YOUR_BUCKET_NAME","arn:aws:s3:::YOUR_BUCKET_NAME/*"]}]}
Note : Veillez à utiliser le principe de moindre privilège en production.
Mise à l'épreuve
Une fois tout mis en place, il est temps de voir votre travail en action :
Déclencher la fonction Lambda :
aws lambda invoke \--fonction-name cnq-nfs-lambda \--payload '{}' \--cli-binary-format raw-en-base64-out \response.json
Vérifiez la fonction en montant l'exportation CNQ NFS sur un système de test et en visualisant le fichier :
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.txtBonjour depuis AWS Lambda via CNQ ! - 2025-04-03T21 :01:21
Débogage : Si vous rencontrez des erreurs, vous pouvez afficher la sortie à des fins de débogage :
aws logs filter-log-events --log-group-name /aws/lambda/cnq-nfs-lambda --limit 5Pourquoi cela est important
L'intégration d'AWS Lambda avec CNQ améliore les capacités sans serveur, permettant des flux de travail avec état transparents sans complexité supplémentaire. La prise en charge multiprotocole de CNQ débloque la compatibilité avec les systèmes existants, offrant un stockage de fichiers robuste et évolutif - rapide, simple et sans serveur.
Bon codage !