Aplicativos sem servidor desenvolvidos com AWS Lambda oferecem agilidade, escalabilidade e eficiência, mas não possuem armazenamento persistente integrado. Quando as funções Lambda precisam acessar arquivos entre invocações ou compartilhar dados de forma persistente, Qumulo Nativo da Nuvem (CNQ) preenche essa lacuna.
Este blog mostra como conectar o AWS Lambda ao CNQ por meio de NFS, permitindo acesso persistente e escalável a arquivos para suas aplicações sem servidor.
Neste blog:
O que é o AWS Lambda?
Por que o AWS Lambda precisa de armazenamento persistente
Configurando o acesso NFS ao CNQ para o Lambda
Criação de uma função Lambda que interage com o CNQ
Empacotamento e implantação do Lambda
Colocando tudo à prova
O que é o AWS Lambda?
O AWS Lambda é um serviço de computação sem servidor e orientado a eventos que executa seu código em resposta a eventos, como solicitações HTTP, envios de arquivos ou alterações no fluxo de dados, sem a necessidade de provisionar ou gerenciar servidores. Ele cuida do dimensionamento, da manutenção e do registro de logs, para que você possa se concentrar em escrever código na linguagem de sua preferência. As funções são executadas somente quando acionadas, e você é cobrado apenas pelo tempo de computação utilizado.
O Lambda é particularmente adequado para cenários que exigem escalonamento rápido e processamento orientado a eventos:
Processamento de arquivos: Acione fluxos de trabalho em tempo real ao enviar arquivos para o Amazon S3.
Processamento de fluxo: analise e processe dados de fluxo em tempo real provenientes de fontes como o Amazon Kinesis.
Aplicativos da Web: Crie aplicativos da Web escaláveis integrando o Lambda a outros serviços da AWS.
Back-ends de IoT: Gerencie as operações de back-end para dispositivos de IoT sem precisar gerenciar servidores.
⚠️ No entanto, o Lambda é, por definição, sem estado. As funções não possuem armazenamento persistente integrado, o que torna necessárias soluções externas para a persistência de arquivos.
Por que o AWS Lambda precisa de armazenamento persistente
A computação sem servidor transformou o desenvolvimento de aplicativos, permitindo que os desenvolvedores criem funções altamente escaláveis sem a necessidade de uma infraestrutura de servidores complexa. Embora as funções Lambda interajam nativamente com o armazenamento de objetos, como o Amazon S3, muitos cenários reais exigem o acesso a sistemas de arquivos tradicionais, seja para dar suporte a aplicativos legados, seja para aproveitar as vantagens que o armazenamento baseado em arquivos oferece.
A opção de armazenamento persistente integrada da Amazon, o Elastic File System (EFS), não oferece suporte ao protocolo SMB, o que limita seu uso a fluxos de trabalho legados que dependem do NFS. Ao integrar o AWS Lambda com o Cloud Native Qumulo (CNQ), os desenvolvedores podem preencher essa lacuna de maneira integrada. Os recursos multiprotocolo do CNQ permitem que aplicativos sem servidor acessem diretamente sistemas de arquivos legados sem comprometer a escalabilidade ou a simplicidade.
Com o CNQ e o AWS Lambda, os fluxos de trabalho com estado tornam-se totalmente sem servidor, oferecendo velocidade, facilidade de uso e capacidade de armazenamento robusta inigualáveis — tudo isso sem complexidade.
Muitas aplicações do mundo real precisam de armazenamento persistente de arquivos:
Geração e salvamento de relatórios
Processamento de arquivos enviados
Compartilhamento de dados entre chamadas ou serviços
O armazenamento temporário /tmp do Lambda é efêmero. O CNQ oferece armazenamento NFS persistente, de alto desempenho, multiprotocolo e escalável, tornando-o ideal para esses cenários.
Configurando o acesso NFS do CNQ para o Lambda
Implemente o CNQ na sua VPC da AWS: Implemente o CNQ pela interface do usuário da Web ou pela CLI do Qumulo em poucos minutos.
Criar uma exportação NFS do Qumulo:
Use a interface do usuário, a API ou a CLI do qq para criar uma exportação para o seu caso de uso do Lambda.
Verifique se sua exportação NFS está correta:
Possui permissões de leitura e gravação
Está acessível na mesma VPC/sub-rede que o Lambda
Permite conexões em portas que não sejam root (o Lambda não é executado como root)
Configurar a segurança do CNQ:
Garanta o acesso de entrada na porta 2049/tcp (NFS):
Adicione o NFS às regras de entrada do Grupo de Segurança da VPC, substituindo o CIDR abaixo pelo intervalo CIDR real da sua sub-rede do Lambda.
aws ec2 authorize-security-group-ingress \--group-id sg-0a1b2c3d4e5f6g7h8 \--protocol tcp \--port 2049 \--cidr 192.168.0.0/24
Criação do código da função Lambda
Crie um arquivo de manipulador em Python (por exemplo, test_cnq_access.py) com o código a seguir.
Observação: Substitua YOUR_CNQ_ADDRESS pelo nome DNS (ou endereço IP) do seu cluster CNQ e YOUR_NFS_EXPORT pelo caminho de exportação NFS real (por exemplo, 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):tentar:nfs = libnfs.NFS("nfs://SEU_ENDEREÇO_CNQ/SUA_EXPORTAÇÃO_NFS")exceto Exceção como e:retornar {"statusCode": 500, "body": "Erro ao se conectar à exportação NFS: " + str(e)}tentar:timestamp = datetime.now().isoformat()message = f"Olá da AWS Lambda via CNQ! - {timestamp}\n"f = nfs.open("/testing-from-lambda.txt", "w+")f.write(message)f.close()exceto Exceção como e:retornar {"statusCode": 500, "body": "Erro ao gravar no arquivo: " + str(e)}tentar:f = nfs.open("/testing-from-lambda.txt", "r") content = f.read()retornar {"statusCode": 200, "body": conteúdo}exceto Exceção como e:retornar {"statusCode": 500, "body": "Erro ao ler o arquivo: " + str(e)}
Empacotamento da função Lambda
Como o AWS Lambda não pode montar FUSE nem utilizar montagens NFS no nível do kernel, incluímos a biblioteca compartilhada nativa libnfs junto com o código Python para utilizar uma alternativa no espaço do usuário.
IMPORTANTE: Faça a compilação e os testes em um ambiente Amazon Linux 2 para verificar a compatibilidade.
Script para criação do pacote de implantação – Crie um script de shell (ou execute esses comandos passo a passo). Adapte-o conforme necessário ao seu ambiente.
#!/bin/bash################################################################# Script de criação do pacote de implantação do AWS Lambda# Execute estas etapas em uma VM ou contêiner do Amazon Linux 2.################################################################BUILD_DIR="/home/ec2-user/build"echo "Criando diretórios do pacote..."mkdir -p "$BUILD_DIR/package/lib"echo "Instalando pacotes pré-requisitos..."sudo yum -y install python3.8 python38-devel gcc libnfs-develsudo amazon-linux-extras enable python3.8echo "Instalando libnfs usando o pip3.8..."pip3.8 install libnfs --target ./packageecho "Copiando a biblioteca compartilhada nativa da AL2 do libnfs para o pacote..."cp -L /usr/lib64/libnfs.so package/lib/echo "Criando um link simbólico para a libnfs no pacote (necessário em tempo de execução)..."cd package/libln -sf libnfs.so libnfs.so.8cd $BUILD_DIRecho "Copiando o script do manipulador Lambda test_cnq_access.py..."cp test_cnq_access.py package/echo "Compactando o pacote de implantação (function.zip)..."cd packagezip -r ../função.zip .
Configuração do IAM
Crie uma política de confiança (trust-policy.json):
{"Versão": "17/10/2012","Declaração": [{"Efeito": "Permitir","Principal": {"Serviço": "lambda.amazonaws.com"},"Ação": "sts:AssumeRole"}]}
Crie e anexe as políticas necessárias:
aws iam create-role \--role-name LambdaCNQExecutionRole \--assume-role-policy-document file://trust-policy.json \--description "Função de execução do Lambda para funções 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
Criação da função Lambda
Substitua “123456789012” pelo ID da sua conta da AWS.
aws lambda create-função \--função-name cnq-nfs-lambda \--runtime python3.8 \--role arn:aws:iam::123456789012:role/LambdaCNQExecutionRole \--handler test_cnq_access.handler \--zip-file fileb://function.zip
Configurando as definições da VPC
Para permitir que sua função Lambda acesse recursos em uma VPC, atualize sua configuração com os detalhes da sua sub-rede e do seu grupo de segurança.
Atualização do AWS Lambda-função-configuração \--função-name cnq-nfs-lambda \--vpc-config '{"SubnetIds": ["subnet-0a1b2c3d", "subnet-4e5f6g7h"],"SecurityGroupIds": ["sg-0abc123def456ghi7"]}'
Opcional: Como aplicar políticas personalizadas adaptadas ao seu caso de uso
Se sua função Lambda precisar acessar serviços adicionais (como o S3), crie uma política personalizada. Por exemplo:
{"Versão": "17/10/2012","Declaração": [{"Sid": "AllowCloudWatchLogs","Effect": "Allow","Action": ["logs:CreateLogGroup","logs:CreateLogStream","logs:PutLogEvents"],"Resource": "arn:aws:logs:*:*:*"},{"Sid": "AllowS3Access","Effect": "Permitir","Action": ["s3:GetObject","s3:PutObject","s3:ListBucket"],"Recurso": ["arn:aws:s3:::YOUR_BUCKET_NAME","arn:aws:s3:::YOUR_BUCKET_NAME/*"]}]}
Observação: certifique-se de seguir o princípio do privilégio mínimo em ambiente de produção.
Colocando à prova
Com tudo configurado, é hora de ver seu trabalho em ação:
Acionar a função Lambda:
aws lambda invoke \--função-name cnq-nfs-lambda \--payload '{}' \--cli-binary-format raw-em-base64-out \response.json
Verifique o funcionamento montando a exportação NFS do CNQ em um sistema de teste e visualizando o arquivo:
$ 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.txtOlá da AWS Lambda via CNQ! - 2025-04-03T21:01:21
Depuração: Se ocorrer algum erro, você pode visualizar a saída para fins de depuração:
aws logs filter-log-events --log-group-name /aws/lambda/cnq-nfs-lambda --limit 5Por que isso é importante
A integração do AWS Lambda com o CNQ aprimora os recursos sem servidor, permitindo fluxos de trabalho com estado de forma contínua, sem complexidade adicional. O suporte multiprotocolo do CNQ garante compatibilidade com sistemas legados, oferecendo um armazenamento de arquivos robusto e escalável — rápido, simples e sem servidor.
Boa programação!