Serverlose Anwendungen, die mit AWS Lambda bieten Flexibilität, Skalierbarkeit und Effizienz, verfügen jedoch nicht über einen integrierten persistenten Speicher. Wenn Lambda-Funktionen über mehrere Aufrufe hinweg auf Dateien zugreifen oder Daten dauerhaft austauschen müssen, Cloud Native Qumulo (CNQ) schließt diese Lücke.
In diesem Blogbeitrag wird gezeigt, wie man AWS Lambda über NFS, wodurch ein dauerhafter und skalierbarer Dateizugriff für Ihre serverlosen Anwendungen ermöglicht wird.
In diesem Blog:
Was ist AWS Lambda?
Warum AWS Lambda persistenten Speicher benötigt
Einrichten des CNQ-NFS-Zugriffs für Lambda
Erstellen einer Lambda-Funktion, die mit CNQ interagiert
Paketierung und Bereitstellung von Lambda
Alles auf die Probe stellen
Was ist AWS Lambda?
AWS Lambda ist ein serverloser, ereignisgesteuerter Rechendienst, der Ihren Code als Reaktion auf Ereignisse wie HTTP-Anfragen, Datei-Uploads oder Änderungen im Datenstrom ausführt, ohne dass Sie Server bereitstellen oder verwalten müssen. AWS Lambda übernimmt die Skalierung, Wartung und Protokollierung, sodass Sie sich ganz auf das Schreiben von Code in der Sprache Ihrer Wahl konzentrieren können. Funktionen werden nur bei Auslösung ausgeführt, und es wird Ihnen lediglich die tatsächlich genutzte Rechenzeit in Rechnung gestellt.
Lambda eignet sich besonders gut für Szenarien, die eine schnelle Skalierung und ereignisgesteuerte Verarbeitung erfordern:
Dateiverarbeitung: Workflows in Echtzeit auslösen, sobald Dateien auf Amazon S3 hochgeladen werden.
Stream-Verarbeitung: Analysieren und verarbeiten Sie Echtzeit-Streaming-Daten aus Quellen wie Amazon Kinesis.
Webanwendungen: Erstellen Sie skalierbare Webanwendungen, indem Sie Lambda in andere AWS-Dienste integrieren.
IoT-Backends: Verwalten Sie den Backend-Betrieb für IoT-Geräte ohne Serververwaltung.
⚠️ Lambda ist jedoch von Haus aus zustandslos. Funktionen verfügen über keinen integrierten persistenten Speicher, sodass für die Dateispeicherung externe Lösungen erforderlich sind.
Warum AWS Lambda persistenten Speicher benötigt
Serverless Computing hat die Anwendungsentwicklung revolutioniert, da es Entwicklern ermöglicht, hochskalierbare Funktionen zu erstellen, ohne dass eine komplexe Serverinfrastruktur erforderlich ist. Zwar interagieren Lambda-Funktionen von Haus aus mit Objektspeichern wie Amazon S3, doch erfordern viele reale Szenarien den Zugriff auf herkömmliche Dateisysteme – sei es zur Unterstützung von Legacy-Anwendungen oder um die Vorteile des dateibasierten Speichers zu nutzen.
Der in Amazon integrierte persistente Speicher „Elastic File System“ (EFS) bietet keine Unterstützung für das SMB-Protokoll, wodurch seine Nutzung auf ältere Workflows beschränkt ist, die auf NFS basieren. Durch die Integration von AWS Lambda mit Cloud Native Qumulo (CNQ) können Entwickler diese Lücke nahtlos schließen. Dank der Multiprotokoll-Fähigkeiten von CNQ können serverlose Anwendungen direkt auf ältere Dateisysteme zugreifen, ohne dabei Abstriche bei der Skalierbarkeit oder Einfachheit machen zu müssen.
Mit CNQ und AWS Lambda werden zustandsbehaftete Workflows vollständig serverlos und bieten unübertroffene Geschwindigkeit, Benutzerfreundlichkeit und robuste Speicherkapazität – und das alles ohne Komplexität.
Viele Anwendungen in der Praxis benötigen eine dauerhafte Dateispeicherung:
Berichte erstellen und speichern
Verarbeitung hochgeladener Dateien
Datenaustausch zwischen Aufrufen oder Diensten
Der temporäre /tmp-Speicher von Lambda ist kurzlebig. CNQ bietet einen dauerhaften, leistungsstarken, protokollübergreifenden und skalierbaren NFS-Speicher, der sich ideal für diese Szenarien eignet.
Einrichten des CNQ-NFS-Zugriffs für Lambda
CNQ in Ihrer AWS-VPC bereitstellen: Stellen Sie CNQ über die Qumulo-Weboberfläche oder die Befehlszeilenschnittstelle (CLI) in wenigen Minuten bereit.
Bereitstellung von Cloud Native Qumulo auf AWS mit CloudFormation
Bereitstellung von Cloud Native Qumulo auf AWS mit Terraform
Einen Qumulo-NFS-Export erstellen:
Verwenden Sie die Benutzeroberfläche, die API oder die qq-Befehlszeilenschnittstelle, um einen Export für Ihren Lambda-Anwendungsfall zu erstellen.
Stellen Sie sicher, dass Ihr NFS-Export:
Verfügt über Lese- und Schreibrechte
Ist innerhalb derselben VPC/desselben Subnetzes wie Lambda erreichbar
Erlaubt Verbindungen über Nicht-Root-Ports (Lambda läuft nicht als Root)
CNQ-Sicherheit konfigurieren:
Stellen Sie den eingehenden Datenverkehr über Port 2049/TCP (NFS) sicher:
Fügen Sie NFS zu den Eingangsregeln der VPC-Sicherheitsgruppe hinzu und ersetzen Sie dabei den unten angegebenen CIDR-Bereich durch den tatsächlichen CIDR-Bereich Ihres Lambda-Subnetzes.
aws ec2 authorize-security-group-ingress \--group-id sg-0a1b2c3d4e5f6g7h8 \--protocol tcp \--port 2049 \--cidr 192.168.0.0/24
Erstellen des Codes für die Lambda-Funktion
Erstellen Sie eine Python-Handler-Datei (z. B. test_cnq_access.py) mit dem folgenden Code.
Hinweis: Ersetzen Sie „YOUR_CNQ_ADDRESS“ durch den DNS-Namen (oder die IP-Adresse) Ihres CNQ-Clusters und „YOUR_NFS_EXPORT“ durch Ihren tatsächlichen NFS-Exportpfad (z. B. „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(event, context):versuchen:nfs = libnfs.NFS("nfs://IHRE_CNQ-ADRESSE/IHR_NFS-EXPORT")außer Ausnahme als e:Zurück {"statusCode": 500, "body": "Fehler beim Herstellen einer Verbindung zum NFS-Export: " + str(e)}versuchen:timestamp = datetime.now().isoformat()message = f"Hallo von AWS Lambda über CNQ! - {timestamp}\n"f = nfs.open("/testing-from-lambda.txt", "w+")f.write(message)f.close()außer Ausnahme als e:Zurück {"statusCode": 500, "body": "Fehler beim Schreiben in die Datei: " + str(e)}versuchen:f = nfs.open("/testing-from-lambda.txt", "r") content = f.read()Zurück {"statusCode": 200, "body": Inhalt}außer Ausnahme als e:Zurück {"statusCode": 500, "body": "Fehler beim Lesen der Datei: " + str(e)}
Die Lambda-Funktion verpacken
Da AWS Lambda weder FUSE einbinden noch NFS-Einbindungen auf Kernel-Ebene nutzen kann, bündeln wir die native libnfs-Shared-Library zusammen mit dem Python-Code, um eine Alternative im User-Space zu nutzen.
WICHTIG: Führen Sie den Build und die Tests zur Überprüfung der Kompatibilität in einer Amazon Linux 2-Umgebung durch.
Skript zur Erstellung eines Bereitstellungspakets – Erstellen Sie ein Shell-Skript (oder führen Sie diese Befehle Schritt für Schritt aus). Passen Sie es bei Bedarf an Ihre Umgebung an.
#!/bin/bash################################################################# Skript zur Erstellung eines AWS Lambda-Bereitstellungspakets# Führen Sie diese Schritte auf einer Amazon Linux 2-VM oder in einem Container aus.################################################################BUILD_DIR="/home/ec2-user/build"echo "Paketverzeichnisse werden erstellt..."mkdir -p "$BUILD_DIR/package/lib"echo "Voraussetzungs-Pakete werden installiert..."sudo yum -y install python3.8 python38-devel gcc libnfs-develsudo amazon-linux-extras enable python3.8echo „libnfs mit pip3.8 installieren...“pip3.8 install libnfs --target ./packageecho „Kopieren der nativen AL2-libnfs-Shared-Library in das Paket...“cp -L /usr/lib64/libnfs.so package/lib/echo „Erstellen eines libnfs-Symlinks im Paket (wird zur Laufzeit benötigt) ...“cd package/libln -sf libnfs.so libnfs.so.8cd $BUILD_DIRecho „Lambda-Handler-Skript ‚test_cnq_access.py‘ wird kopiert...“cp test_cnq_access.py package/echo „Bereitstellungspaket (function.zip) wird gezippt...“cd packagezip -r ../Funktion.zip .
IAM-Konfiguration
Erstellen Sie eine Vertrauensrichtlinie (trust-policy.json):
{"Version": "2012-10-17","Statement": [{"Effect": "Allow","Principal": {"Service": "lambda.amazonaws.com"},"Action": "sts:AssumeRole"}]}
Erstellen Sie die erforderlichen Richtlinien und fügen Sie diese bei:
aws iam create-role \--role-name LambdaCNQExecutionRole \--assume-role-policy-document file://trust-policy.json \--description „Lambda-Ausführungsrolle für CNQ-Funktionen“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
Erstellen der Lambda-Funktion
Ersetzen Sie „123456789012“ durch Ihre AWS-Konto-ID.
aws lambda create-Funktion \--Funktion-name cnq-nfs-lambda \--runtime python3.8 \--role arn:aws:iam::123456789012:role/LambdaCNQExecutionRole \--handler test_cnq_access.handler \--zip-file fileb://function.zip
Konfigurieren der VPC-Einstellungen
Damit Ihre Lambda-Funktion auf Ressourcen in einer VPC zugreifen kann, müssen Sie ihre Konfiguration mit den Angaben zu Ihrem Subnetz und Ihrer Sicherheitsgruppe aktualisieren.
AWS Lambda-Update-Funktion-Konfiguration \--Funktion-name cnq-nfs-lambda \--vpc-config '{"SubnetIds": ["subnet-0a1b2c3d", "subnet-4e5f6g7h"],"SecurityGroupIds": ["sg-0abc123def456ghi7"]}'
Optional: Anwenden benutzerdefinierter Richtlinien, die auf Ihren Anwendungsfall zugeschnitten sind
Wenn Ihre Lambda-Funktion auf zusätzliche Dienste (wie S3) zugreifen muss, erstellen Sie eine benutzerdefinierte Richtlinie. Beispiel:
{"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/*"]}]}
Hinweis: Achten Sie darauf, in der Produktion das Prinzip der geringsten Berechtigungen anzuwenden.
Auf dem Prüfstand
Nachdem nun alles eingerichtet ist, ist es an der Zeit, Ihre Arbeit in Aktion zu sehen:
Lösen Sie die Lambda-Funktion aus:
AWS Lambda aufrufen \--Funktion-name cnq-nfs-lambda \--payload '{}' \--cli-binary-format raw-in-base64-out \response.json
Überprüfen Sie die Funktion, indem Sie den CNQ-NFS-Export auf einem Testsystem einbinden und die Datei anzeigen:
$ 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.txtHallo von AWS Lambda über CNQ! – 2025-04-03T21:01:21
Fehlerbehebung: Sollten Fehler auftreten, können Sie die Ausgabe zu Zwecken der Fehlerbehebung einsehen:
aws logs filter-log-events --log-group-name /aws/lambda/cnq-nfs-lambda --limit 5 Warum das wichtig ist
Die Integration von AWS Lambda in CNQ erweitert die serverlosen Funktionen und ermöglicht nahtlose, zustandsbehaftete Workflows ohne zusätzliche Komplexität. Die Multiprotokoll-Unterstützung von CNQ gewährleistet die Kompatibilität mit Altsystemen und bietet eine robuste, skalierbare Dateispeicherung – schnell, einfach und serverlos.
Viel Spaß beim Programmieren!