# Transformar objetos com o S3 Object Lambda
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Com o Amazon S3 Object Lambda, você pode adicionar seu próprio código às solicitações `GET`, `LIST` e `HEAD` do Amazon S3 para modificar e processar dados, conforme eles são retornados para uma aplicação. Você pode usar o código personalizado para modificar os dados retornados por solicitações `GET` do S3 para filtrar linhas, redimensionar imagens e marcas d’água dinamicamente, editar dados confidenciais e muito mais. Você também pode usar o S3 Object Lambda para modificar a saída das solicitações `LIST` do S3 para criar uma visualização personalizada de todos os objetos em um bucket e as solicitações `HEAD` do S3 para modificar os metadados do objeto, como nome e tamanho do objeto. Você pode usar o S3 Object Lambda como origem para sua distribuição do Amazon CloudFront a fim de personalizar dados para usuários finais, como redimensionar imagens automaticamente, transcodificar formatos mais antigos (como de JPEG para WebP) ou remover metadados. Para obter mais informações, consulte a publicação do blog da AWS [Usar o Amazon S3 Object Lambda com o Amazon CloudFront](https://aws.amazon.com/blogs/aws/new-use-amazon-s3-object-lambda-with-amazon-cloudfront-to-tailor-content-for-end-users/). Alimentado pelas funções do AWS Lambda, seu código é executado em uma infraestrutura totalmente gerenciada pela AWS. O uso do S3 Object Lambda reduz a necessidade de criar e armazenar cópias derivadas de seus dados ou de executar proxies, tudo sem a necessidade de alterar suas aplicações.
**Como o S3 Object Lambda funciona**
O S3 Object Lambda usa funções do AWS Lambda para processar automaticamente a saída de solicitações `GET`, `LIST` e `HEAD` padrão do S3. O AWS Lambda é um serviço de computação sem servidor que executa código definido pelo cliente sem exigir o gerenciamento de recursos de computação subjacentes. Você pode criar e executar suas próprias funções do Lambda personalizadas, adaptando a transformação de dados para seus casos de uso específicos.
Depois de configurar uma função do Lambda, anexe-a a um endpoint de serviço do S3 Object Lambda, conhecido como *ponto de acesso do Object Lambda*. O ponto de acesso do Object Lambda usa um ponto de acesso padrão do S3, conhecido como *ponto de acesso de suporte*, para acessar os dados.
Quando você envia uma solicitação para seu ponto de acesso do Object Lambda, o Amazon S3 chama automaticamente a função do Lambda. Qualquer dado recuperado usando uma solicitação `GET`, `LIST` ou `HEAD` do S3 por meio do ponto de acesso do Object Lambda retorna um resultado transformado de volta à aplicação. Todas as outras solicitações são processadas como normais, conforme ilustrado no diagrama a seguir.
![\[Diagrama que mostra como o S3 Object Lambda funciona.\]](http://docs.aws.amazon.com/pt_br/AmazonS3/latest/userguide/images/ObjectLamdaDiagram.png)
Os tópicos nesta seção descrevem como trabalhar com o S3 Object Lambda.
**Topics**
+ [
# Criar pontos de acesso do Object Lambda
](olap-create.md)
+ [
# Usar pontos de acesso do Amazon S3 Object Lambda
](olap-use.md)
+ [
# Considerações sobre segurança para pontos de acesso do S3 Object Lambda
](olap-security.md)
+ [
# Escrever funções do Lambda para pontos de acesso do S3 Object Lambda
](olap-writing-lambda.md)
+ [
# Uso de funções do Lambda criadas pela AWS
](olap-examples.md)
+ [
# Práticas recomendadas e diretrizes para o S3 Object Lambda
](olap-best-practices.md)
+ [
# Tutoriais do S3 Object Lambda
](olap-tutorials.md)
+ [
# Depurar e solucionar problemas do S3 Object Lambda
](olap-debugging-lambda.md)
# Criar pontos de acesso do Object Lambda
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Um ponto de acesso do Object Lambda está associado exatamente a um único ponto de acesso padrão, que você especifica durante a criação. Para criar um ponto de acesso do Object Lambda, você precisa dos seguintes recursos:
+ **Um ponto de acesso do S3 padrão.** Quando você trabalha com pontos de acesso do Object Lambda, esse ponto de acesso padrão é conhecido como *ponto de acesso de suporte* e está anexado a um bucket do S3 ou a um volume do Amazon FSx para OpenZFS. Para obter informações sobre a criação de pontos de acesso padrão, consulte [Criar um ponto de acesso](creating-access-points.md).
+ **Uma função do AWS Lambda.** Você pode criar sua própria função do Lambda ou usar uma função pré-criada. Para obter mais informações sobre como criar funções do Lambda, consulte [Escrever funções do Lambda para pontos de acesso do S3 Object Lambda](olap-writing-lambda.md). Para obter mais informações sobre funções pré-construídas, consulte [Uso de funções do Lambda criadas pela AWS](olap-examples.md).
+ **(Opcional) Uma política do AWS Identity and Access Management (IAM).** Os pontos de acesso do Amazon S3 são compatíveis com políticas de recursos do IAM que você pode usar para controlar o uso do ponto de acesso por recurso, usuário ou outras condições. Para obter mais informações sobre como criar essas políticas, consulte [Configurar políticas do IAM para pontos de acesso do Object Lambda](olap-policies.md).
As seções a seguir descrevem como criar um ponto de acesso do Object Lambda usando:
+ A Console de gerenciamento da AWS
+ A AWS Command Line Interface (AWS CLI)
+ Um modelo do AWS CloudFormation
+ O AWS Cloud Development Kit (AWS CDK)
Para obter informações sobre como criar um ponto de acesso do Object Lambda usando a API REST, consulte [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessPointForObjectLambda.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessPointForObjectLambda.html) na *Referência de API do Amazon Simple Storage Service*.
## Criar um ponto de acesso do Object Lambda
Use um dos procedimentos a seguir para criar o ponto de acesso do Object Lambda.
### Usar o console do S3
**Para criar um ponto de acesso do Object Lambda usando o console**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Na barra de navegação, escolha o nome da Região da AWS exibida no momento. Em seguida, escolha a região para a qual você deseja mudar.
1. No painel de navegação à esquerda, escolha **Object Lambda access points** (Pontos de acesso do Object Lambda).
1. Na página **Object Lambda Access Points** (Pontos de acesso do Object Lambda), escolha **Create Object Lambda Access Point** (Criar ponto de acesso do Object Lambda).
1. Em **Object Lambda Access Point name** (Nome do ponto de acesso do Object Lambda), insira o nome que deseja usar para o ponto de acesso.
Tal como acontece com pontos de acesso padrão, existem regras para nomeação de pontos de acesso do Object Lambda. Para obter mais informações, consulte [Regras de nomenclatura para pontos de acesso](access-points-restrictions-limitations-naming-rules.md#access-points-names).
1. Para **Supporting Access Point (Ponto de acesso de suporte)**, insira ou navegue até o ponto de acesso padrão que você deseja usar. O ponto de acesso deve estar na mesma Região da AWS que os objetos que você deseja transformar. Para obter informações sobre a criação de pontos de acesso padrão, consulte [Criar um ponto de acesso](creating-access-points.md).
1. Em **Configuração de transformação**, você pode adicionar uma função que transforma os dados para o ponto de acesso do Object Lambda. Execute um destes procedimentos:
+ Se você já tem uma função do AWS Lambda em sua conta, pode escolhê-la em **Invoke Lambda function** (Invocar função do Lambda). Aqui você pode inserir o nome do recurso da Amazon (ARN) de uma função do Lambda em sua Conta da AWS ou escolher uma função do Lambda no menu suspenso.
+ Se você quiser usar uma função integrada à AWS, escolha o nome da função em **Função criada pela AWS** e selecione **Criar função do Lambda**. Isso levará você ao console do Lambda, onde poderá implantar uma função integrada à sua Conta da AWS. Para obter mais informações sobre funções integradas, consulte [Uso de funções do Lambda criadas pela AWS](olap-examples.md).
Em **S3 APIs** (APIs do S3), escolha uma ou mais operações de API para invocar. Para cada API selecionada, você deve especificar uma função do Lambda para invocar.
1. (Opcional) Em **Payload** (Carga útil), adicione o texto JSON que você quer fornecer para a função do Lambda como entrada. Você pode configurar cargas com parâmetros diferentes para pontos de acesso do Object Lambda diferentes que invocam a mesma função do Lambda, estendendo, assim, a flexibilidade da função do Lambda.
**Importante**
Ao usar os pontos de acesso do Object Lambda, verifique se a carga útil não contém informações sigilosas.
1. (Opcional) Em **Range and part number** (Intervalo e número de peça), você deve habilitar essa opção a fim processar solicitações `GET` e `HEAD` com cabeçalhos de intervalo e número de peça. Habilitar essa opção confirma que sua função do Lambda é capaz de reconhecer e processar essas solicitações. Para obter mais informações sobre cabeçalhos de intervalo e números de peça, consulte [Trabalhar com cabeçalhos Range e partNumber](range-get-olap.md).
1. (Opcional) Em **Métricas de solicitação**, escolha **Ativar** ou **Desativar** para adicionar o monitoramento do Amazon S3 ao ponto de acesso do Object Lambda. As métricas de solicitação são cobradas na taxa padrão do Amazon CloudWatch.
1. (Opcional) Em **Object Lambda Access Point policy** (Política de ponto de acesso do Object Lambda), defina uma política de recursos. As políticas de recursos concedem permissões para o ponto de acesso do Object Lambda especificado e podem controlar o uso do ponto de acesso por recurso, usuário ou outras condições. Para obter mais informações sobre as políticas de recursos de ponto de acesso do Object Lambda, consulte [Configurar políticas do IAM para pontos de acesso do Object Lambda](olap-policies.md).
1. Em **Block Public Access settings for this Object Lambda Access Point** (Configurações de bloqueio de acesso público para este ponto de acesso do Object Lambda), selecione as configurações de bloqueio de acesso público que você deseja aplicar. Todas as configurações de bloqueio de acesso público são habilitadas por padrão para novos pontos de acesso do Object Lambda, e recomendamos que você deixe as configurações padrão habilitadas. Atualmente, o Amazon S3 não oferece suporte à alteração das configurações de bloqueio de acesso público a pontos de acesso do Object Lambda após a criação de pontos de acesso do Object Lambda.
Para obter mais informações sobre como usar o bloqueio de acesso público do Amazon S3, consulte [Gerenciar o acesso público a pontos de acesso para buckets de uso geral](access-points-bpa-settings.md).
1. Escolha **Create Object Lambda Access Point** (Criar ponto de acesso do Object Lambda).
### Como usar o AWS CLI
**Para criar um ponto de acesso do Object Lambda usando um modelo do AWS CloudFormation**
**nota**
Para usar os comandos a seguir, substitua `user input placeholders` por suas próprias informações.
1. Baixe o pacote de implantação da função `s3objectlambda_deployment_package.zip` do AWS Lambda em [S3 Object Lambda default configuration](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration) (Configuração padrão do S3 Object Lambda).
1. Execute o comando `put-object` a seguir para fazer upload do pacote em um bucket do Amazon S3.
```
aws s3api put-object --bucket Amazon S3 bucket name --key s3objectlambda_deployment_package.zip --body release/s3objectlambda_deployment_package.zip
```
1. Baixe o modelo `s3objectlambda_defaultconfig.yaml` do AWS CloudFormation em [S3 Object Lambda default configuration](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration) (Configuração padrão do S3 Object Lambda).
1. Execute o comando `deploy` a seguir para implantar o modelo em sua Conta da AWS.
```
aws cloudformation deploy --template-file s3objectlambda_defaultconfig.yaml \
--stack-name CloudFormation stack name \
--parameter-overrides ObjectLambdaAccessPointName=Object Lambda Access Point name \
SupportingAccessPointName=Amazon S3 access point S3BucketName=Amazon S3 bucket \
LambdaFunctionS3BucketName=Amazon S3 bucket containing your Lambda package \
LambdaFunctionS3Key=Lambda object key LambdaFunctionS3ObjectVersion=Lambda object version \
LambdaFunctionRuntime=Lambda function runtime --capabilities capability_IAM
```
Você pode configurar esse modelo do AWS CloudFormation para invocar o Lambda para as operações de API `GET`, `HEAD` e `LIST`. Para obter mais informações sobre como modificar a configuração padrão do modelo, consulte [Automatizar a configuração do S3 Object Lambda com um modelo do CloudFormation](olap-using-cfn-template.md).
**Para criar um ponto de acesso do Object Lambda usando a AWS CLI**
**nota**
Para usar os comandos a seguir, substitua `user input placeholders` por suas próprias informações.
O exemplo a seguir cria um ponto de acesso do Object Lambda chamado *`my-object-lambda-ap`* para o bucket *`amzn-s3-demo-bucket1`* na conta *`111122223333`*. Esse exemplo pressupõe que um ponto de acesso padrão denominado *`example-ap`* já tenha sido criado. Para obter informações sobre como criar um ponto de acesso padrão, consulte [Criar um ponto de acesso](creating-access-points.md).
Este exemplo usa a função pré-criada `decompress` da AWS. Para obter mais informações sobre funções pré-construídas, consulte [Uso de funções do Lambda criadas pela AWS](olap-examples.md).
1. Crie um bucket. Neste exemplo, usaremos *`amzn-s3-demo-bucket1`*. Para obter mais informações sobre a criação de buckets, consulte [Criar um bucket de uso geral](create-bucket-overview.md).
1. Crie um ponto de acesso padrão e anexe-o ao seu bucket. Neste exemplo, usaremos *`example-ap`*. Para obter informações sobre a criação de pontos de acesso padrão, consulte [Criar um ponto de acesso](creating-access-points.md).
1. Execute um destes procedimentos:
+ Crie na conta uma função do Lambda que você deseja usar para transformar o objeto do Simple Storage Service (Amazon S3). Para obter mais informações sobre como criar funções do Lambda, consulte [Escrever funções do Lambda para pontos de acesso do S3 Object Lambda](olap-writing-lambda.md). Para usar sua função personalizada com a AWS CLI, consulte [Como usar o Lambda com a AWS CLI](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-awscli.html) no *Guia do desenvolvedor do AWS Lambda*.
+ Use uma função do Lambda pré-criada pela AWS. Para obter mais informações sobre funções pré-construídas, consulte [Uso de funções do Lambda criadas pela AWS](olap-examples.md).
1. Crie um arquivo de configuração JSON chamado `my-olap-configuration.json`. Nessa configuração, forneça o ponto de acesso de suporte e o nome do recurso da Amazon (ARN) para a função do Lambda que você criou nas etapas anteriores ou o ARN da função pré-criada que você está usando.
**Example**
```
{
"SupportingAccessPoint" : "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap",
"TransformationConfigurations": [{
"Actions" : ["GetObject", "HeadObject", "ListObjects", "ListObjectsV2"],
"ContentTransformation" : {
"AwsLambda": {
"FunctionPayload" : "{\"compressionType\":\"gzip\"}",
"FunctionArn" : "arn:aws:lambda:us-east-1:111122223333:function/compress"
}
}
}]
}
```
1. Execute o comando `create-access-point-for-object-lambda` para criar o ponto de acesso do Object Lambda.
```
aws s3control create-access-point-for-object-lambda --account-id 111122223333 --name my-object-lambda-ap --configuration file://my-olap-configuration.json
```
1. (Opcional) Crie um arquivo de política JSON chamado `my-olap-policy.json`.
Adicionar uma política de recursos de ponto de acesso do Object Lambda pode controlar o uso do ponto de acesso por recurso, usuário ou outras condições. Essa política de recursos concede a permissão `GetObject` para a conta *`444455556666`* ao ponto de acesso do Object Lambda especificado.
**Example**
```
{
"Version": "2008-10-17",
"Statement": [
{
"Sid": "Grant account 444455556666 GetObject access",
"Effect": "Allow",
"Action": "s3-object-lambda:GetObject",
"Principal": {
"AWS": "arn:aws:iam::444455556666:root"
},
"Resource": "your-object-lambda-access-point-arn"
}
]
}
```
1. (Opcional) Execute o comando `put-access-point-policy-for-object-lambda` para definir sua política de recursos.
```
aws s3control put-access-point-policy-for-object-lambda --account-id 111122223333 --name my-object-lambda-ap --policy file://my-olap-policy.json
```
1. (Opcional) Especifique uma carga útil.
Uma carga útil é um JSON opcional que você pode fornecer à sua função do AWS Lambda como entrada. Você pode configurar cargas com parâmetros diferentes para pontos de acesso do Object Lambda diferentes que invocam a mesma função do Lambda, estendendo, assim, a flexibilidade da função do Lambda.
A configuração do ponto de acesso do Object Lambda a seguir mostra uma carga útil com dois parâmetros.
```
{
"SupportingAccessPoint": "AccessPointArn",
"CloudWatchMetricsEnabled": false,
"TransformationConfigurations": [{
"Actions": ["GetObject", "HeadObject", "ListObjects", "ListObjectsV2"],
"ContentTransformation": {
"AwsLambda": {
"FunctionArn": "FunctionArn",
"FunctionPayload": "{\"res-x\": \"100\",\"res-y\": \"100\"}"
}
}
}]
}
```
A configuração de ponto de acesso do Object Lambda a seguir mostra uma carga útil com um único parâmetro e com `GetObject-Range`, `GetObject-PartNumber`, `HeadObject-Range` e `HeadObject-PartNumber` ativados.
```
{
"SupportingAccessPoint":"AccessPointArn",
"CloudWatchMetricsEnabled": false,
"AllowedFeatures": ["GetObject-Range", "GetObject-PartNumber", "HeadObject-Range", "HeadObject-PartNumber"],
"TransformationConfigurations": [{
"Action": ["GetObject", "HeadObject", "ListObjects", "ListObjectsV2"],
"ContentTransformation": {
"AwsLambda": {
"FunctionArn":"FunctionArn",
"FunctionPayload": "{\"compression-amount\": \"5\"}"
}
}
}]
}
```
**Importante**
Ao usar os pontos de acesso do Object Lambda, verifique se a carga útil não contém informações sigilosas.
### Usar o console e o template do AWS CloudFormation
É possível criar um ponto de acesso do Object Lambda usando a configuração padrão fornecida pelo Amazon S3. Você pode baixar um modelo do AWS CloudFormation e o código-fonte da função do Lambda do [repositório do GitHub](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration) e implantar esses recursos para configurar um ponto de acesso funcional do Object Lambda.
Para obter informações sobre como modificar a configuração padrão do template do AWS CloudFormation, consulte [Automatizar a configuração do S3 Object Lambda com um modelo do CloudFormation](olap-using-cfn-template.md).
Para obter informações sobre como configurar pontos de acesso do Object Lambda usando o CloudFormation sem o modelo, consulte [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-s3objectlambda-accesspoint.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-s3objectlambda-accesspoint.html) no *Guia do usuário do AWS CloudFormation*.
**Para carregar o pacote de implantação da função Lambda**
1. Baixe o pacote de implantação da função `s3objectlambda_deployment_package.zip` do AWS Lambda em [S3 Object Lambda default configuration](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration) (Configuração padrão do S3 Object Lambda).
1. Faça upload do pacote em um bucket do Amazon S3.
**Para criar um ponto de acesso do Object Lambda usando o console do AWS CloudFormation**
1. Baixe o modelo `s3objectlambda_defaultconfig.yaml` do AWS CloudFormation em [S3 Object Lambda default configuration](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration) (Configuração padrão do S3 Object Lambda).
1. Faça login no Console de Gerenciamento da AWS e abra o console do AWS CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Execute um destes procedimentos:
+ Se você nunca usou o AWS CloudFormation, na página inicial do AWS CloudFormation, escolha **Create stack** (Criar pilha).
+ Se você já usou o AWS CloudFormation, no painel de navegação à esquerda, selecione **Stacks** (Pilhas). Selecione **Create stack** (Criar pilha), depois escolha **With new resources (standard)** (Com novos recursos (padrão)).
1. Em **Prerequisite - Prepare template** (Pré-requisito - Preparar template), escolha **Template is ready** (O template está pronto).
1. Em **Specify template** (Especificar modelo), escolha **Upload a template file** (Fazer upload de um arquivo de modelo) e faça upload de `s3objectlambda_defaultconfig.yaml`.
1. Escolha **Próximo**.
1. Na página **Specify stack details** (Especificar detalhes da pilha), insira um nome para a pilha.
1. Na seção **Parameters** (Parâmetros), especifique os parâmetros que são definidos no modelo da pilha:
1. Em **CreateNewSupportingAccessPoint**, siga um destes procedimentos:
+ Se você já tem um ponto de acesso de suporte para o bucket do S3 em que fez upload do modelo, escolha **false** (falso).
+ Se quiser criar um ponto de acesso para esse bucket, selecione **true** (verdadeiro).
1. Para **EnableCloudWatchMonitoring**, escolha **true** (verdadeiro) ou **false** (falso), dependendo se deseja habilitar as métricas e os alarmes de solicitação do Amazon CloudWatch.
1. (Opcional) Em **LambdaFunctionPayload**, adicione o texto JSON que você quer fornecer para a função do Lambda como entrada. Você pode configurar cargas com parâmetros diferentes para pontos de acesso do Object Lambda diferentes que invocam a mesma função do Lambda, estendendo, assim, a flexibilidade da função do Lambda.
**Importante**
Ao usar os pontos de acesso do Object Lambda, verifique se a carga útil não contém informações sigilosas.
1. Em **LambdaFunctionRuntime**, insira seu tempo de execução preferido para a função do Lambda. As opções disponíveis são , e `nodejs14.x`, `python3.9`, `java11`.
1. Em **LambdaFunctionS3BucketName**, insira o nome do bucket do Amazon S3 para o qual você fez upload do pacote de implantação.
1. Em **LambdaFunctionS3Key**, insira o nome da chave de objeto do Amazon S3 para o qual você fez upload do pacote de implantação.
1. Em **LambdaFunctionS3Key**, insira a versão do objeto do Amazon S3 no qual você fez upload do pacote de implantação.
1. Em **ObjectLambdaAccessPointName**, insira um nome para o ponto de acesso do Object Lambda.
1. Em **S3BucketName**, insira o nome do bucket do Amazon S3 que será associado ao ponto de acesso do Object Lambda.
1. Em **SupportingAccessPointName**, insira o nome de seu ponto de acesso de suporte.
**nota**
Trata-se de um ponto de acesso associado ao bucket do Amazon S3 que você escolheu na etapa anterior. Caso não tenha nenhum ponto de acesso associado ao bucket do Amazon S3, você poderá configurar o modelo para criar um selecionando **true** (verdadeiro) em **CreateNewSupportingAccessPoint**.
1. Escolha **Avançar**.
1. Na página **Configurar opções de pilha**, selecione **Avançar**.
Para obter mais informações sobre as configurações opcionais nesta página, consulte [Configurar opções de pilha do AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-add-tags.html) no *Guia do usuário do AWS CloudFormation*.
1. Na página **Review** (Revisão), escolha **Create stack** (Criar pilha).
### Como usar o AWS Cloud Development Kit (AWS CDK)
Para obter mais informações sobre como configurar pontos de acesso do Object Lambda usando o AWS CDK, consulte [Biblioteca de estruturas do `AWS::S3ObjectLambda`](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-s3objectlambda-readme.html) na *Referência de API do AWS Cloud Development Kit (AWS CDK)*.
# Automatizar a configuração do S3 Object Lambda com um modelo do CloudFormation
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Você pode usar um modelo do AWS CloudFormation para criar rapidamente um ponto de acesso do Amazon S3 Object Lambda. O modelo do CloudFormation cria automaticamente recursos relevantes, configura perfis do AWS Identity and Access Management (IAM) e configura uma função do AWS Lambda que lida automaticamente com solicitações por meio do ponto de acesso do Object Lambda. Com o modelo do CloudFormation, é possível implementar práticas recomendadas, melhorar seu procedimento de segurança e reduzir erros causados por processos manuais.
Esse [repositório GitHub](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration) contém o modelo do CloudFormation e o código-fonte da função do Lambda. Para obter instruções sobre como usar o modelo, consulte [Criar pontos de acesso do Object Lambda](olap-create.md).
A função do Lambda fornecida no modelo não executa nenhuma transformação. Em vez disso, ele retorna seus objetos como estão da fonte de dados subjacente. Você pode clonar a função e adicionar seu próprio código de transformação para modificar e processar dados à medida que eles são retornados a uma aplicação. Para obter mais informações sobre como modificar a função, consulte [Modificar a função Lambda](#modifying-lambda-function) e [Escrever funções do Lambda para pontos de acesso do S3 Object Lambda](olap-writing-lambda.md).
## Modificar o template
**Criar um ponto de acesso de suporte**
O S3 Object Lambda usa dois pontos de acesso: um ponto de acesso do Object Lambda e um ponto de acesso padrão do S3, chamado de *ponto de acesso de suporte*. Quando você faz uma solicitação a um ponto de acesso do Object Lambda, o S3 chama o Lambda em seu nome ou delega a solicitação ao ponto de acesso de suporte, de acordo com a configuração do S3 Object Lambda. É possível criar um ponto de acesso de suporte transmitindo o seguinte parâmetro como parte do comando `aws cloudformation deploy` ao implantar o modelo.
```
CreateNewSupportingAccessPoint=true
```
**Configurar uma carga útil de função**
Você pode configurar uma carga útil para fornecer dados complementares à função Lambda transmitindo o seguinte parâmetro como parte do comando `aws cloudformation deploy` ao implantar o template.
```
LambdaFunctionPayload="format=json"
```
**Habilitar o monitoramento do Amazon CloudWatch**
Você pode habilitar o monitoramento do CloudWatch transmitindo o seguinte parâmetro como parte do comando `aws cloudformation deploy` ao implantar o template.
```
EnableCloudWatchMonitoring=true
```
Esse parâmetro habilita o ponto de acesso do Object Lambda para métricas de solicitação do Amazon S3 e cria dois alarmes do CloudWatch para monitorar erros no lado do cliente e no lado do servidor.
**nota**
O uso do Amazon CloudWatch incorrerá em custos adicionais. Para obter mais informações sobre métricas de solicitação do Amazon S3, consulte [Monitorar e registrar de pontos de acesso](access-points-monitoring-logging.md).
Para obter detalhes sobre os preços, consulte [Definição de preço do CloudWatch](https://aws.amazon.com/cloudwatch/pricing/).
**Configurar a simultaneidade provisionada**
Para reduzir a latência, é possível configurar a simultaneidade provisionada para a função do Lambda com base no ponto de acesso do Object Lambda editando o modelo para incluir as seguintes linhas em `Resources`.
```
LambdaFunctionVersion:
Type: AWS::Lambda::Version
Properties:
FunctionName: !Ref LambdaFunction
ProvisionedConcurrencyConfig:
ProvisionedConcurrentExecutions: Integer
```
**nota**
Haverá cobranças adicionais pela simultaneidade de provisionamento. Para obter mais informações sobre simultaneidade provisionada, consulte [Gerenciar a simultaneidade provisionada do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html) no *Guia do desenvolvedor do AWS Lambda*.
Para obter detalhes de preço, consulte [Definição de preço do AWS Lambda](https://aws.amazon.com/lambda/pricing/).
## Modificar a função Lambda
**Alterar os valores do cabeçalho de uma solicitação `GetObject`**
Por padrão, a função do Lambda encaminha todos os cabeçalhos, exceto `Content-Length` e `ETag`, da solicitação de URL pré-assinado ao cliente do `GetObject`. Com base em seu código de transformação na função Lambda, é possível escolher enviar novos valores de cabeçalho ao cliente do `GetObject`.
Você pode atualizar sua função do Lambda para enviar novos valores de cabeçalho, transmitindo-os na operação de API `WriteGetObjectResponse`.
Por exemplo, se a função Lambda traduzir texto em objetos do Amazon S3 para um idioma diferente, você poderá transmitir um novo valor no cabeçalho `Content-Language`. Faça isso modificando a função `writeResponse`, conforme mostrado abaixo:
```
async function writeResponse (s3Client: S3, requestContext: GetObjectContext, transformedObject: Buffer,
headers: Headers): Promise> {
const { algorithm, digest } = getChecksum(transformedObject);
return s3Client.writeGetObjectResponse({
RequestRoute: requestContext.outputRoute,
RequestToken: requestContext.outputToken,
Body: transformedObject,
Metadata: {
'body-checksum-algorithm': algorithm,
'body-checksum-digest': digest
},
...headers,
ContentLanguage: 'my-new-language'
}).promise();
}
```
Para obter uma lista completa dos cabeçalhos compatíveis, consulte [https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax](https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax) na *Referência da API do Amazon Simple Storage Service*.
**Retornar cabeçalhos de metadados**
Você pode atualizar sua função do Lambda para enviar novos valores de cabeçalho, transmitindo-os na solicitação de operação de API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax](https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax).
```
async function writeResponse (s3Client: S3, requestContext: GetObjectContext, transformedObject: Buffer,
headers: Headers): Promise> {
const { algorithm, digest } = getChecksum(transformedObject);
return s3Client.writeGetObjectResponse({
RequestRoute: requestContext.outputRoute,
RequestToken: requestContext.outputToken,
Body: transformedObject,
Metadata: {
'body-checksum-algorithm': algorithm,
'body-checksum-digest': digest,
'my-new-header': 'my-new-value'
},
...headers
}).promise();
}
```
**Retornar um novo código de status**
É possível retornar um código de status personalizado ao cliente do `GetObject` transmitindo-o na solicitação de operação de API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax](https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax).
```
async function writeResponse (s3Client: S3, requestContext: GetObjectContext, transformedObject: Buffer,
headers: Headers): Promise> {
const { algorithm, digest } = getChecksum(transformedObject);
return s3Client.writeGetObjectResponse({
RequestRoute: requestContext.outputRoute,
RequestToken: requestContext.outputToken,
Body: transformedObject,
Metadata: {
'body-checksum-algorithm': algorithm,
'body-checksum-digest': digest
},
...headers,
StatusCode: Integer
}).promise();
}
```
Para obter uma lista completa dos códigos de status compatíveis, consulte [https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax](https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax) na *Referência da API do Amazon Simple Storage Service*.
**Aplicar os parâmetros `Range` e `partNumber` no objeto de origem**
Por padrão, o ponto de acesso do Object Lambda criado pelo modelo do CloudFormation pode lidar com os parâmetros `Range` e `partNumber`. A função Lambda aplica o intervalo ou o número da parte solicitado ao objeto transformado. Para isso, a função precisa baixar o objeto inteiro e executar a transformação. Em alguns casos, os intervalos de objetos transformados podem mapear exatamente para seus intervalos de objetos de origem. Isso significa que solicitar o intervalo de bytes A–B no objeto de origem e executar a transformação poderá produzir o mesmo resultado que solicitar o objeto inteiro, executar a transformação e retornar o intervalo de bytes A–B no objeto transformado.
Nesses casos, é possível alterar a implementação da função Lambda para aplicar o intervalo ou o número da parte diretamente no objeto de origem. Essa abordagem reduz a latência geral da função e a memória necessárias. Para obter mais informações, consulte [Trabalhar com cabeçalhos Range e partNumber](range-get-olap.md).
**Desabilitar o tratamento de `Range` e `partNumber`**
Por padrão, o ponto de acesso do Object Lambda criado pelo modelo do CloudFormation pode lidar com os parâmetros `Range` e `partNumber`. Se você não precisar desse comportamento, poderá desabilitá-lo removendo as seguintes linhas do modelo:
```
AllowedFeatures:
- GetObject-Range
- GetObject-PartNumber
- HeadObject-Range
- HeadObject-PartNumber
```
**Transformar objetos grandes**
Por padrão, a função Lambda processa todo o objeto na memória antes que ele possa começar a transmitir a resposta ao S3 Object Lambda. É possível modificar a função para transmitir a resposta à medida que ela executa a transformação. Isso ajuda a reduzir a latência de transformação e o tamanho da memória da função do Lambda. Para obter um exemplo de implementação, consulte o [Exemplo de conteúdo compactado de transmissão](olap-writing-lambda.md#olap-getobject-response).
# Usar pontos de acesso do Amazon S3 Object Lambda
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Fazer solicitações via Pontos de Acesso do Amazon S3 Object Lambda funciona da mesma forma que fazer solicitações por meio de outros pontos de acesso. Para obter mais informações sobre como fazer solicitações via ponto de acesso, consulte [Usar o recurso Pontos de Acesso Amazon S3 para buckets de uso geral](using-access-points.md). Você pode fazer solicitações via pontos de acesso do Object Lambda usando o console do Amazon S3, a AWS Command Line Interface (AWS CLI), AWS SDKs ou API REST do Amazon S3.
**Importante**
Os nomes do recursos da Amazon (ARNs) para pontos de acesso do Object Lambda usam um nome de serviço de `s3-object-lambda`. Assim, os ARNs dos pontos de acesso do Object Lambda começam com `arn:aws::s3-object-lambda`, em vez do prefixo `arn:aws::s3` usado com outros pontos de acesso.
## Como encontrar o ARN do ponto de acesso do Object Lambda
Para usar um ponto de acesso do Object Lambda com a AWS CLI ou AWS SDKs, é necessário saber o nome do recurso da Amazon (ARN) do ponto de acesso do Object Lambda. Os exemplos a seguir mostram como encontrar o ARN para um ponto de acesso do Object Lambda usando o console ou a AWS CLI do Amazon S3.
### Usar o console do S3
**Para encontrar o ARN do seu ponto de acesso do Object Lambda usando o console**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Object Lambda access points** (Pontos de acesso do Object Lambda).
1. Selecione o botão de opção próximo ao ponto de acesso do Object Lambda cujo ARN você deseja copiar.
1. Escolha **Copy ARN** (Copiar ARN).
### Como usar o AWS CLI
**Para encontrar o ARN do ponto de acesso do Object Lambda usando a AWS CLI**
1. Para recuperar uma lista dos pontos de acesso do Object Lambda associados à Conta da AWS, execute o comando a seguir. Antes de executar o comando, substitua o ID da conta *`111122223333`* pelo ID da sua Conta da AWS.
```
aws s3control list-access-points-for-object-lambda --account-id 111122223333
```
1. Revise a saída do comando para localizar o ARN do ponto de acesso do Object Lambda que deseja usar. A saída do comando anterior será semelhante à saída do exemplo a seguir.
```
{
"ObjectLambdaAccessPointList": [
{
"Name": "my-object-lambda-ap",
"ObjectLambdaAccessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/my-object-lambda-ap"
},
...
]
}
```
## Como usar um alias no estilo do bucket para o ponto de acesso do Object Lambda do bucket do S3
Quando você cria um ponto de acesso do Object Lambda, o Amazon S3 gera automaticamente um alias exclusivo para seu ponto de acesso do Object Lambda. É possível usar esse alias em vez de um nome de bucket do Amazon S3 ou o nome do recurso da Amazon (ARN) do ponto de acesso do Object Lambda em uma solicitação para operações de plano de dados do ponto de acesso. Para obter uma lista dessas operações, consulte [Compatibilidade dos pontos de acesso](access-points-service-api-support.md).
Um nome de alias do ponto de acesso do Object Lambda é criado dentro do mesmo namespace de um bucket do Amazon S3. Esse nome de alias é gerado automaticamente, e não é possível alterá-lo. Para um ponto de acesso do Object Lambda existente, um alias é automaticamente atribuído para uso. Um nome de alias de ponto de acesso do Object Lambda atende a todos os requisitos de um nome de bucket válido do Amazon S3 e consiste nas seguintes partes:
`Object Lambda Access Point name prefix-metadata--ol-s3`
**nota**
O sufixo `--ol-s3` é reservado para nomes de alias de ponto de acesso e não pode ser usado para nomes de bucket ou de ponto de acesso do Object Lambda. Para obter mais informações sobre as regras para nomes de bucket do Amazon S3, consulte [Regras de nomenclatura de buckets de uso geral](bucketnamingrules.md).
Os exemplos a seguir mostram o ARN e o alias de ponto de acesso do Object Lambda para um ponto de acesso do Object Lambda chamado `my-object-lambda-access-point`:
+ **ARN** – `arn:aws:s3-object-lambda:region:account-id:accesspoint/my-object-lambda-access-point`
+ **Alias de ponto de acesso do Object Lambda** – `my-object-lambda-acc-1a4n8yjrb3kda96f67zwrwiiuse1a--ol-s3`
Ao usar um ponto de acesso do Object Lambda, você pode usar o nome do alias do ponto de acesso do Object Lambda sem exigir grandes alterações no código.
Quando você exclui um ponto de acesso do Object Lambda, o nome do alias do ponto de acesso do Object Lambda se torna inativo e não provisionado.
### Como encontrar o alias do ponto de acesso do Object Lambda
#### Usar o console do S3
**Para encontrar o alias do ponto de acesso do Object Lambda usando o console**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Object Lambda access points** (Pontos de acesso do Object Lambda).
1. Para o ponto de acesso do Object Lambda que você deseja usar, copie o valor do **alias do ponto de acesso do Object Lambda**.
#### Como usar o AWS CLI
Quando você cria um ponto de acesso do Object Lambda, o Amazon S3 gera automaticamente um nome de alias de ponto de acesso do Object Lambda, conforme mostrado no exemplo de comando a seguir. Para executar esse comando, substitua os `user input placeholders` por suas próprias informações. Para obter informações sobre como criar um ponto de acesso do Object Lambda usando a AWS CLI, consulte [Para criar um ponto de acesso do Object Lambda usando a AWS CLI](olap-create.md#olap-create-cli-specific).
```
aws s3control create-access-point-for-object-lambda --account-id 111122223333 --name my-object-lambda-access-point --configuration file://my-olap-configuration.json
{
"ObjectLambdaAccessPointArn": "arn:aws:s3:region:111122223333:accesspoint/my-access-point",
"Alias": {
"Value": "my-object-lambda-acc-1a4n8yjrb3kda96f67zwrwiiuse1a--ol-s3",
"Status": "READY"
}
}
```
O nome do alias do ponto de acesso do Object Lambda gerado tem dois campos:
+ O campo `Value` é o valor do alias do ponto de acesso do Object Lambda.
+ O campo `Status` é o status do alias do ponto de acesso do Object Lambda. Se o status for `PROVISIONING`, o Amazon S3 estará provisionando o alias do ponto de acesso do Object Lambda, e o alias ainda não estará pronto para uso. Se o status for `READY`, o alias do ponto de acesso do Object Lambda terá sido provisionado com êxito e estará pronto para uso.
Para obter mais informações sobre o tipo de dados `ObjectLambdaAccessPointAlias` na API REST, consulte [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessPointForObjectLambda.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessPointForObjectLambda.html) e [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_ObjectLambdaAccessPointAlias.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_ObjectLambdaAccessPointAlias.html) na *Referência da API do Amazon Simple Storage Service*.
### Como usar o alias do ponto de acesso do Object Lambda
É possível usar um alias de ponto de acesso do Object Lambda em vez de um nome de bucket do Amazon S3 para as operações listadas em [Compatibilidade dos pontos de acesso](access-points-service-api-support.md).
O exemplo da AWS CLI a seguir para o comando `get-bucket-location` usa o alias do ponto de acesso do bucket para retornar a Região da AWS em que o bucket está. Para executar esse comando, substitua os `user input placeholders` por suas próprias informações.
```
aws s3api get-bucket-location --bucket my-object-lambda-acc-w7i37nq6xuzgax3jw3oqtifiusw2a--ol-s3
{
"LocationConstraint": "us-west-2"
}
```
Se o alias do ponto de acesso do Object Lambda em uma solicitação não for válido, o código de erro `InvalidAccessPointAliasError` será retornado. Para obter mais informações sobre `InvalidAccessPointAliasError`, consulte [Lista de códigos de erro](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList) na *Referência de API do Amazon Simple Storage Service*.
As limitações de um alias de um ponto de acesso do Object Lambda são as mesmas de um alias de ponto de acesso. Para obter mais informações sobre os limites de um alias do ponto de acesso, consulte [Limitações dos alias de ponto de acesso](access-points-naming.md#use-ap-alias-limitations).
# Considerações sobre segurança para pontos de acesso do S3 Object Lambda
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Com o Amazon S3 Object Lambda, você pode realizar transformações personalizadas em dados à medida que deixa o S3 usando a escala e a flexibilidade do AWS Lambda como uma plataforma de computação. O S3 e o Lambda permanecem seguros por padrão, mas, para manter a segurança, é necessária uma consideração especial do autor da função do Lambda. O S3 Object Lambda exige que todo o acesso seja feito por entidades autenticadas (sem acesso anônimo) e por HTTPS.
Para mitigar os riscos de segurança, recomendamos o seguinte:
+ Defina o escopo do perfil de execução do Lambda com o menor conjunto de permissões possível.
+ Sempre que possível, verifique se a função do Lambda acessa o Amazon S3 por meio do URL pré-assinado fornecido.
## Configurar políticas do IAM
Os pontos de acesso do S3 são compatíveis com as políticas de recursos do AWS Identity and Access Management (IAM) que permitem controlar o uso do ponto de acesso por recurso, usuário ou por outras condições. Para obter mais informações, consulte [Configurar políticas do IAM para pontos de acesso do Object Lambda](olap-policies.md).
## Comportamento de criptografia
Como os pontos de acesso do Object Lambda usam o Amazon S3 e o AWS Lambda, há diferenças no comportamento de criptografia. Para obter mais informações sobre o comportamento de criptografia padrão do S3, consulte [Definir o comportamento padrão da criptografia para os buckets do Amazon S3](bucket-encryption.md).
+ Quando você usa a criptografia do lado do servidor do S3 com pontos de acesso do Object Lambda, o objeto é descriptografado antes de ser enviado para o Lambda. Depois que o objeto é enviado para o Lambda, ele é processado sem criptografia (no caso de uma solicitação `GET` ou `HEAD`).
+ Para evitar que a chave de criptografia seja registrada em log, o S3 rejeitará solicitações `GET` e `HEAD` para objetos criptografados usando criptografia no servidor com chaves fornecidas pelo cliente (SSE-C). No entanto, a função do Lambda ainda pode recuperar esses objetos desde que tenha acesso à chave fornecida pelo cliente.
+ Ao usar a criptografia do lado do cliente do S3 com pontos de acesso do Object Lambda, verifique se o Lambda tem acesso à chave de criptografia para descriptografar e criptografar novamente o objeto.
## Segurança dos pontos de acesso
O S3 Object Lambda usa dois pontos de acesso: um ponto de acesso do Object Lambda e um ponto de acesso padrão do S3, chamado de *ponto de acesso de suporte*. Quando você faz uma solicitação a um ponto de acesso do Object Lambda, o S3 chama o Lambda em seu nome ou delega a solicitação ao ponto de acesso de suporte, de acordo com a configuração do S3 Object Lambda. Quando o Lambda é chamado para uma solicitação, o S3 gera um URL pré-assinado para seu objeto em seu nome por meio do ponto de acesso de suporte. Sua função do Lambda receberá esse URL como entrada quando a função for chamada.
É possível definir sua função do Lambda para usar esse URL pré-assinado ao recuperar o objeto original, em vez de chamar o S3 diretamente. Usando esse modelo, você pode aplicar melhores limites de segurança a seus objetos. É possível limitar o acesso direto a objetos por meio de buckets do S3 ou de pontos de acesso do S3 a um conjunto limitado de funções ou usuários do IAM. Essa abordagem também protege suas funções do Lambda de estarem sujeitas ao [problema Confused Deputy](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html), no qual uma função mal configurada com permissões diferentes das permissões de seu chamador poderia permitir ou negar acesso a objetos quando não deveria.
## Acesso público do ponto de acesso do Object Lambda
O S3 Object Lambda não permite acesso anônimo ou público, pois o Amazon S3 precisa autorizar sua identidade para concluir qualquer solicitação do S3 Object Lambda. Ao chamar solicitações por um ponto de acesso do Object Lambda, é necessário ter a permissão `lambda:InvokeFunction` para a função do Lambda configurada. Da mesma forma, ao chamar outras operações de API por um ponto de acesso do Object Lambda, você precisa ter as permissões `s3:*` necessárias.
Sem essas permissões, as solicitações para chamar o Lambda ou delegar ao S3 apresentarão falha com erros HTTP 403 (Proibido). Todo o acesso deve ser feito por entidades autenticadas. Se precisar de acesso público, use o Lambda@Edge como uma possível alternativa. Para obter mais informações, consulte [Personalizar o conteúdo na borda com o Lambda@Edge](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-at-the-edge.html) no *Guia do desenvolvedor do Amazon CloudFront*.
## Endereços IP de ponto de acesso do Object Lambda
As sub-redes de `describe-managed-prefix-lists` são compatíveis com endpoints de nuvem privada virtual (VPC) do gateway e são relacionadas à tabela de roteamento de endpoints da VPC. Como o ponto de acesso do Object Lambda não é compatível com a VPC do gateway, seus intervalos de IP estão ausentes. Os intervalos ausentes pertencem ao Amazon S3, mas não são compatíveis com endpoints da VPC de gateway. Para obter mais informações sobre `describe-managed-prefix-lists`, consulte [DescribeManagedPrefixLists](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeManagedPrefixLists.html) na *Referência da API do Amazon EC2* e [Intervalos de endereços IP da AWS](https://docs.aws.amazon.com/general/latest/gr/aws-ip-ranges.html) na *Referência geral da AWS*.
# Configurar políticas do IAM para pontos de acesso do Object Lambda
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Os pontos de acesso do Amazon S3 são compatíveis com as políticas de recursos do AWS Identity and Access Management (IAM) que você pode usar para controlar o uso do ponto de acesso por recurso, usuário ou outras condições. Você pode controlar o acesso por meio de uma política de recursos opcional no ponto de acesso do Object Lambda ou uma política de recursos no ponto de acesso de suporte. Para obter um exemplo detalhado, consulte [Tutorial: Como transformar dados para sua aplicação com o S3 Object Lambda](tutorial-s3-object-lambda-uppercase.md) e [Tutorial: Detectar e editar dados PII com o S3 Object Lambda e o Amazon Comprehend](tutorial-s3-object-lambda-redact-pii.md).
Os quatro recursos a seguir devem ter permissões concedidas para trabalhar com pontos de acesso do Object Lambda:
+ A identidade do IAM, como um usuário ou um perfil. Para obter mais informações sobre as identidades do IAM e as práticas recomendadas, consulte [Identidades do IAM (usuários, grupos de usuários e perfis)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) no *Guia do usuário do IAM*.
+ O ponto de acesso padrão conectado a uma fonte de dados subjacente, como um bucket do S3 ou um volume do Amazon FSx para OpenZFS. Quando você trabalha com pontos de acesso do Object Lambda, esse ponto de acesso padrão é conhecido como *ponto de acesso de suporte*.
+ O ponto de acesso do Object Lambda.
+ A função do AWS Lambda.
**Importante**
Antes de salvar a política, solucione os avisos de segurança, os erros, os avisos gerais e as sugestões de AWS Identity and Access Management Access Analyzer. O IAM Access Analyzer executa verificações de política para validar sua política em relação à [gramática das políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_grammar.html) e às [práticas recomendadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) do IAM. Essas verificações geram descobertas e fornecem recomendações práticas que ajudam a criar políticas que sejam funcionais e estejam em conformidade com as práticas recomendadas de segurança.
Para saber mais sobre a validação de políticas usando o IAM Access Analyzer, consulte [Validação de políticas do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) no *Guia do usuário do IAM*. Para visualizar uma lista de avisos, erros e sugestões retornados pelo IAM Access Analyzer, consulte [Referência de verificação de políticas do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-reference-policy-checks.html).
Os seguintes exemplos de política assumem que você tem os seguintes recursos:
+ Um bucket do Amazon S3 com o seguinte nome do recurso da Amazon (ARN):
`arn:aws:s3:::amzn-s3-demo-bucket1`
+ Um ponto de acesso do Amazon S3 Standard nesse bucket com o seguinte ARN:
`arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point`
+ Um ponto de acesso do Object Lambda com o seguinte ARN:
`arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/my-object-lambda-ap`
+ Uma função do AWS Lambda com o seguinte ARN:
`arn:aws:lambda:us-east-1:111122223333:function:MyObjectLambdaFunction`
**nota**
Se estiver usando uma função do Lambda em sua conta, você deverá incluir a versão da função na declaração da política. No seguinte exemplo de ARN, a versão é indicada por *1*:
`arn:aws:lambda:us-east-1:111122223333:function:MyObjectLambdaFunction:1`
O Lambda não permite adicionar políticas do IAM à versão `$LATEST`. Para obter mais informações sobre as versões de funções do Lambda, consulte [Versões de funções do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-versions.html) no *Guia do desenvolvedor do AWS Lambda*.
**Example : Política de buckets que delega controle de acesso a pontos de acesso**
O exemplo de política de buckets do S3 a seguir delega o controle de acesso para um bucket aos pontos de acesso padrão do bucket. Essa política permite total acesso a todos os pontos de acesso pertencentes à conta do proprietário do bucket. Assim, todo o acesso a esse bucket é controlado pelas políticas anexadas aos seus pontos de acesso. Os usuários só podem ler no bucket por meio de um ponto de acesso, o que significa que as operações só podem ser invocadas por meio dos pontos de acesso. Para obter mais informações, consulte [Delegar controle de acesso a pontos de acesso](access-points-policies.md#access-points-delegating-control).
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect": "Allow",
"Principal" : { "AWS":"account-ARN"},
"Action" : "*",
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
],
"Condition": {
"StringEquals" : { "s3:DataAccessPointAccount" : "Bucket owner's account ID" }
}
}]
}
```
**Example : política do IAM que concede ao usuário as permissões necessárias para usar um ponto de acesso do Object Lambda**
A seguinte política do IAM concede a um usuário permissões para a função do Lambda, o ponto de acesso padrão e o ponto de acesso do Object Lambda.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowLambdaInvocation",
"Action": [
"lambda:InvokeFunction"
],
"Effect": "Allow",
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:MyObjectLambdaFunction:1",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": [
"s3-object-lambda.amazonaws.com"
]
}
}
},
{
"Sid": "AllowStandardAccessPointAccess",
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": [
"s3-object-lambda.amazonaws.com"
]
}
}
},
{
"Sid": "AllowObjectLambdaAccess",
"Action": [
"s3-object-lambda:Get*",
"s3-object-lambda:List*"
],
"Effect": "Allow",
"Resource": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/my-object-lambda-ap"
}
]
}
```
## Habilitar permissões para funções de execução do Lambda
Quando são feitas solicitações `GET` a um ponto de acesso do Object Lambda, a função do Lambda precisa de permissão para enviar dados ao ponto de acesso do S3 Object Lambda. Isso é fornecido habilitando a permissão `s3-object-lambda:WriteGetObjectResponse` na função de execução da sua função do Lambda. Crie uma nova função de execução ou atualize uma existente.
**nota**
Sua função precisa da permissão `s3-object-lambda:WriteGetObjectResponse` somente se você estiver fazendo uma solicitação `GET`.
**Como criar uma função de execução no console do IAM**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação à esquerda, escolha **Funções**.
1. Selecione **Create role** (Criar função).
1. Em **Common use cases (Casos de uso comuns)**, selecione **Lambda**.
1. Escolha **Próximo**.
1. Na página **Add permissions** (Adicionar permissões), pesquise a política [https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AmazonS3ObjectLambdaExecutionRolePolicy$serviceLevelSummary](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AmazonS3ObjectLambdaExecutionRolePolicy$serviceLevelSummary)gerenciada pela AWS e marque a caixa de seleção ao lado do nome da política.
Essa política deve conter a ação `s3-object-lambda:WriteGetObjectResponse`.
1. Escolha **Próximo**.
1. Na página **Name, review, and create** (Nomear, revisar e criar), para **Role name** (Nome da função), insira **s3-object-lambda-role**.
1. (Opcional) Adicione uma descrição e etiquetas para esse perfil.
1. Selecione **Criar perfil**.
1. Aplique a **s3-object-lambda-role** recém-criada como a função de execução de sua função Lambda. Isso pode ser feito durante ou após a criação da função do Lambda no console do Lambda.
Para obter informações sobre funções de execução, consulte [Função de execução do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) no *Guia do desenvolvedor do AWS Lambda*.
## Usar chaves de contexto com pontos de acesso do Object Lambda
O S3 Object Lambda avaliará chaves de contexto, como `s3-object-lambda:TlsVersion` ou `s3-object-lambda:AuthType`, relacionadas à conexão ou assinatura da solicitação. Todas as outras chaves de contexto, como `s3:prefix`, são avaliadas pelo Simple Storage Service (Amazon S3).
## Suporte ao CORS de ponto de acesso do Object Lambda
Ao receber uma solicitação de um navegador ou quando a solicitação inclui um cabeçalho `Origin`, o S3 Object Lambda sempre adiciona um campo de cabeçalho `"AllowedOrigins":"*"`.
Para obter mais informações, consulte [Usar o compartilhamento de recursos de origem cruzada (CORS)](cors.md).
# Escrever funções do Lambda para pontos de acesso do S3 Object Lambda
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Essa seção apresenta detalhes de como escrever funções do AWS Lambda para usar com pontos de acesso do Amazon S3 Object Lambda.
Para saber mais sobre procedimentos completos para algumas tarefas do S3 Object Lambda, consulte o seguinte:
+ [Tutorial: Como transformar dados para sua aplicação com o S3 Object Lambda](tutorial-s3-object-lambda-uppercase.md)
+ [Tutorial: Detectar e editar dados PII com o S3 Object Lambda e o Amazon Comprehend](tutorial-s3-object-lambda-redact-pii.md)
+ [Tutorial: Using S3 Object Lambda to dynamically watermark images as they are retrieved (Tutorial: Como usar o S3 Object Lambda para colocar marca d’água em imagens de maneira dinâmica à medida que são recuperadas](https://aws.amazon.com/getting-started/hands-on/amazon-s3-object-lambda-to-dynamically-watermark-images/?ref=docs_gateway/amazons3/olap-writing-lambda.html)
**Topics**
+ [
## Trabalhar com solicitações `GetObject` no Lambda
](#olap-getobject-response)
+ [
## Trabalhar com solicitações `HeadObject` no Lambda
](#olap-headobject)
+ [
## Trabalhar com solicitações `ListObjects` no Lambda
](#olap-listobjects)
+ [
## Trabalhar com solicitações `ListObjectsV2` no Lambda
](#olap-listobjectsv2)
+ [
# Formato e uso de contexto de evento
](olap-event-context.md)
+ [
# Trabalhar com cabeçalhos Range e partNumber
](range-get-olap.md)
## Trabalhar com solicitações `GetObject` no Lambda
Esta seção pressupõe que seu ponto de acesso do Object Lambda está configurado para chamar a função do Lambda para `GetObject`. O S3 Object Lambda inclui a operação de API do Amazon S3, `WriteGetObjectResponse`, que permite que a função do Lambda apresente dados personalizados e cabeçalhos de resposta para o chamador de `GetObject`.
`WriteGetObjectResponse` oferece controle extensivo sobre código de status, cabeçalhos de resposta e corpo de resposta, com base nas suas necessidades de processamento. Você pode usar `WriteGetObjectResponse` para responder com todo o objeto transformado, partes do objeto transformado ou outras respostas com base no contexto da sua aplicação. A seção a seguir mostra exemplos exclusivos do uso da operação da API `WriteGetObjectResponse`.
+ **Exemplo 1:** Responder com código de status HTTP 403 (Proibido)
+ **Exemplo 2:**responda com uma imagem transformada
+ **Exemplo 3:** Transmitir conteúdo compactado
**Exemplo 1: Responder com código de status HTTP 403 (Proibido) **
Você pode usar `WriteGetObjectResponse` para responder com o código de status HTTP 403 (Proibido) com base no conteúdo do objeto.
------
#### [ Java ]
```
package com.amazon.s3.objectlambda;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.events.S3ObjectLambdaEvent;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.WriteGetObjectResponseRequest;
import java.io.ByteArrayInputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class Example1 {
public void handleRequest(S3ObjectLambdaEvent event, Context context) throws Exception {
S3Client s3Client = S3Client.builder().build();
// Check to see if the request contains all of the necessary information.
// If it does not, send a 4XX response and a custom error code and message.
// Otherwise, retrieve the object from S3 and stream it
// to the client unchanged.
var tokenIsNotPresent = !event.getUserRequest().getHeaders().containsKey("requiredToken");
if (tokenIsNotPresent) {
s3Client.writeGetObjectResponse(WriteGetObjectResponseRequest.builder()
.requestRoute(event.outputRoute())
.requestToken(event.outputToken())
.statusCode(403)
.contentLength(0L)
.errorCode("MissingRequiredToken")
.errorMessage("The required token was not present in the request.")
.build(),
RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0L));
return;
}
// Prepare the presigned URL for use and make the request to S3.
HttpClient httpClient = HttpClient.newBuilder().build();
var presignedResponse = httpClient.send(
HttpRequest.newBuilder(new URI(event.inputS3Url())).GET().build(),
HttpResponse.BodyHandlers.ofInputStream());
// Stream the original bytes back to the caller.
s3Client.writeGetObjectResponse(WriteGetObjectResponseRequest.builder()
.requestRoute(event.outputRoute())
.requestToken(event.outputToken())
.build(),
RequestBody.fromInputStream(presignedResponse.body(),
presignedResponse.headers().firstValueAsLong("content-length").orElse(-1L)));
}
}
```
------
#### [ Python ]
```
import boto3
import requests
def handler(event, context):
s3 = boto3.client('s3')
"""
Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
should be delivered and contains a presigned URL in 'inputS3Url' where we can download the requested object from.
The 'userRequest' object has information related to the user who made this 'GetObject' request to
S3 Object Lambda.
"""
get_context = event["getObjectContext"]
user_request_headers = event["userRequest"]["headers"]
route = get_context["outputRoute"]
token = get_context["outputToken"]
s3_url = get_context["inputS3Url"]
# Check for the presence of a 'CustomHeader' header and deny or allow based on that header.
is_token_present = "SuperSecretToken" in user_request_headers
if is_token_present:
# If the user presented our custom 'SuperSecretToken' header, we send the requested object back to the user.
response = requests.get(s3_url)
s3.write_get_object_response(RequestRoute=route, RequestToken=token, Body=response.content)
else:
# If the token is not present, we send an error back to the user.
s3.write_get_object_response(RequestRoute=route, RequestToken=token, StatusCode=403,
ErrorCode="NoSuperSecretTokenFound", ErrorMessage="The request was not secret enough.")
# Gracefully exit the Lambda function.
return { 'status_code': 200 }
```
------
#### [ Node.js ]
```
const { S3 } = require('aws-sdk');
const axios = require('axios').default;
exports.handler = async (event) => {
const s3 = new S3();
// Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
// should be delivered and contains a presigned URL in 'inputS3Url' where we can download the requested object from.
// The 'userRequest' object has information related to the user who made this 'GetObject' request to S3 Object Lambda.
const { userRequest, getObjectContext } = event;
const { outputRoute, outputToken, inputS3Url } = getObjectContext;
// Check for the presence of a 'CustomHeader' header and deny or allow based on that header.
const isTokenPresent = Object
.keys(userRequest.headers)
.includes("SuperSecretToken");
if (!isTokenPresent) {
// If the token is not present, we send an error back to the user. The 'await' in front of the request
// indicates that we want to wait for this request to finish sending before moving on.
await s3.writeGetObjectResponse({
RequestRoute: outputRoute,
RequestToken: outputToken,
StatusCode: 403,
ErrorCode: "NoSuperSecretTokenFound",
ErrorMessage: "The request was not secret enough.",
}).promise();
} else {
// If the user presented our custom 'SuperSecretToken' header, we send the requested object back to the user.
// Again, note the presence of 'await'.
const presignedResponse = await axios.get(inputS3Url);
await s3.writeGetObjectResponse({
RequestRoute: outputRoute,
RequestToken: outputToken,
Body: presignedResponse.data,
}).promise();
}
// Gracefully exit the Lambda function.
return { statusCode: 200 };
}
```
------
**Exemplo 2:responda com uma imagem transformada**
Ao executar uma transformação de imagem, talvez você ache que precisa de todos os bytes do objeto de origem antes de começar a processá-los. Nesse caso, a solicitação `WriteGetObjectResponse` retorna todo o objeto para a aplicação solicitante em uma chamada.
------
#### [ Java ]
```
package com.amazon.s3.objectlambda;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.events.S3ObjectLambdaEvent;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.WriteGetObjectResponseRequest;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.awt.Image;
import java.io.ByteArrayOutputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class Example2V2 {
private static final int HEIGHT = 250;
private static final int WIDTH = 250;
public void handleRequest(S3ObjectLambdaEvent event, Context context) throws Exception {
S3Client s3Client = S3Client.builder().build();
HttpClient httpClient = HttpClient.newBuilder().build();
// Prepare the presigned URL for use and make the request to S3.
var presignedResponse = httpClient.send(
HttpRequest.newBuilder(new URI(event.inputS3Url())).GET().build(),
HttpResponse.BodyHandlers.ofInputStream());
// The entire image is loaded into memory here so that we can resize it.
// Once the resizing is completed, we write the bytes into the body
// of the WriteGetObjectResponse request.
var originalImage = ImageIO.read(presignedResponse.body());
var resizingImage = originalImage.getScaledInstance(WIDTH, HEIGHT, Image.SCALE_DEFAULT);
var resizedImage = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
resizedImage.createGraphics().drawImage(resizingImage, 0, 0, WIDTH, HEIGHT, null);
var baos = new ByteArrayOutputStream();
ImageIO.write(resizedImage, "png", baos);
// Stream the bytes back to the caller.
s3Client.writeGetObjectResponse(WriteGetObjectResponseRequest.builder()
.requestRoute(event.outputRoute())
.requestToken(event.outputToken())
.build(), RequestBody.fromBytes(baos.toByteArray()));
}
}
```
------
#### [ Python ]
```
import boto3
import requests
import io
from PIL import Image
def handler(event, context):
"""
Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
should be delivered and has a presigned URL in 'inputS3Url' where we can download the requested object from.
The 'userRequest' object has information related to the user who made this 'GetObject' request to
S3 Object Lambda.
"""
get_context = event["getObjectContext"]
route = get_context["outputRoute"]
token = get_context["outputToken"]
s3_url = get_context["inputS3Url"]
"""
In this case, we're resizing .png images that are stored in S3 and are accessible through the presigned URL
'inputS3Url'.
"""
image_request = requests.get(s3_url)
image = Image.open(io.BytesIO(image_request.content))
image.thumbnail((256,256), Image.ANTIALIAS)
transformed = io.BytesIO()
image.save(transformed, "png")
# Send the resized image back to the client.
s3 = boto3.client('s3')
s3.write_get_object_response(Body=transformed.getvalue(), RequestRoute=route, RequestToken=token)
# Gracefully exit the Lambda function.
return { 'status_code': 200 }
```
------
#### [ Node.js ]
```
const { S3 } = require('aws-sdk');
const axios = require('axios').default;
const sharp = require('sharp');
exports.handler = async (event) => {
const s3 = new S3();
// Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
// should be delivered and has a presigned URL in 'inputS3Url' where we can download the requested object from.
const { getObjectContext } = event;
const { outputRoute, outputToken, inputS3Url } = getObjectContext;
// In this case, we're resizing .png images that are stored in S3 and are accessible through the presigned URL
// 'inputS3Url'.
const { data } = await axios.get(inputS3Url, { responseType: 'arraybuffer' });
// Resize the image.
const resized = await sharp(data)
.resize({ width: 256, height: 256 })
.toBuffer();
// Send the resized image back to the client.
await s3.writeGetObjectResponse({
RequestRoute: outputRoute,
RequestToken: outputToken,
Body: resized,
}).promise();
// Gracefully exit the Lambda function.
return { statusCode: 200 };
}
```
------
**Exemplo 3: Transmitir conteúdo compactado**
Quando objetos são comprimidos, os dados compactados são produzidos de forma incremental. Consequentemente, você pode usar sua solicitação `WriteGetObjectResponse` para retornar os dados compactados assim que eles estiverem prontos. Como mostrado neste exemplo, não é necessário saber o tamanho da transformação concluída.
------
#### [ Java ]
```
package com.amazon.s3.objectlambda;
import com.amazonaws.services.lambda.runtime.events.S3ObjectLambdaEvent;
import com.amazonaws.services.lambda.runtime.Context;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.WriteGetObjectResponseRequest;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class Example3 {
public void handleRequest(S3ObjectLambdaEvent event, Context context) throws Exception {
S3Client s3Client = S3Client.builder().build();
HttpClient httpClient = HttpClient.newBuilder().build();
// Request the original object from S3.
var presignedResponse = httpClient.send(
HttpRequest.newBuilder(new URI(event.inputS3Url())).GET().build(),
HttpResponse.BodyHandlers.ofInputStream());
// Consume the incoming response body from the presigned request,
// apply our transformation on that data, and emit the transformed bytes
// into the body of the WriteGetObjectResponse request as soon as they're ready.
// This example compresses the data from S3, but any processing pertinent
// to your application can be performed here.
var bodyStream = new GZIPCompressingInputStream(presignedResponse.body());
// Stream the bytes back to the caller.
s3Client.writeGetObjectResponse(WriteGetObjectResponseRequest.builder()
.requestRoute(event.outputRoute())
.requestToken(event.outputToken())
.build(),
RequestBody.fromInputStream(bodyStream,
presignedResponse.headers().firstValueAsLong("content-length").orElse(-1L)));
}
}
```
------
#### [ Python ]
```
import boto3
import requests
import zlib
from botocore.config import Config
"""
A helper class to work with content iterators. Takes an interator and compresses the bytes that come from it. It
implements 'read' and '__iter__' so that the SDK can stream the response.
"""
class Compress:
def __init__(self, content_iter):
self.content = content_iter
self.compressed_obj = zlib.compressobj()
def read(self, _size):
for data in self.__iter__()
return data
def __iter__(self):
while True:
data = next(self.content)
chunk = self.compressed_obj.compress(data)
if not chunk:
break
yield chunk
yield self.compressed_obj.flush()
def handler(event, context):
"""
Setting the 'payload_signing_enabled' property to False allows us to send a streamed response back to the client.
in this scenario, a streamed response means that the bytes are not buffered into memory as we're compressing them,
but instead are sent straight to the user.
"""
my_config = Config(
region_name='eu-west-1',
signature_version='s3v4',
s3={
"payload_signing_enabled": False
}
)
s3 = boto3.client('s3', config=my_config)
"""
Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
should be delivered and has a presigned URL in 'inputS3Url' where we can download the requested object from.
The 'userRequest' object has information related to the user who made this 'GetObject' request to S3 Object Lambda.
"""
get_context = event["getObjectContext"]
route = get_context["outputRoute"]
token = get_context["outputToken"]
s3_url = get_context["inputS3Url"]
# Compress the 'get' request stream.
with requests.get(s3_url, stream=True) as r:
compressed = Compress(r.iter_content())
# Send the stream back to the client.
s3.write_get_object_response(Body=compressed, RequestRoute=route, RequestToken=token, ContentType="text/plain",
ContentEncoding="gzip")
# Gracefully exit the Lambda function.
return {'status_code': 200}
```
------
#### [ Node.js ]
```
const { S3 } = require('aws-sdk');
const axios = require('axios').default;
const zlib = require('zlib');
exports.handler = async (event) => {
const s3 = new S3();
// Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
// should be delivered and has a presigned URL in 'inputS3Url' where we can download the requested object from.
const { getObjectContext } = event;
const { outputRoute, outputToken, inputS3Url } = getObjectContext;
// Download the object from S3 and process it as a stream, because it might be a huge object and we don't want to
// buffer it in memory. Note the use of 'await' because we want to wait for 'writeGetObjectResponse' to finish
// before we can exit the Lambda function.
await axios({
method: 'GET',
url: inputS3Url,
responseType: 'stream',
}).then(
// Gzip the stream.
response => response.data.pipe(zlib.createGzip())
).then(
// Finally send the gzip-ed stream back to the client.
stream => s3.writeGetObjectResponse({
RequestRoute: outputRoute,
RequestToken: outputToken,
Body: stream,
ContentType: "text/plain",
ContentEncoding: "gzip",
}).promise()
);
// Gracefully exit the Lambda function.
return { statusCode: 200 };
}
```
------
**nota**
Embora o S3 Object Lambda permita enviar uma resposta completa ao autor da chamada por meio da solicitação `WriteGetObjectResponse`, a quantidade real de tempo disponível pode ser menor. Por exemplo, o tempo limite da função do Lambda pode ser inferior a 60 segundos. Em outros casos, o autor da chamada pode ter tempos limites mais rigorosos.
Para que o autor da chamada original receba uma resposta diferente de código de status HTTP 500 (Erro interno do servidor), a chamada `WriteGetObjectResponse` deve ser concluída. Se a função do Lambda retornar, excepcionalmente ou de outra forma, antes que a operação da API `WriteGetObjectResponse` seja chamada, o autor da chamada original receberá uma resposta 500 (Erro interno do servidor). Exceções lançadas durante o tempo necessário para concluir a resposta resultam em respostas truncadas ao autor da chamada. Se a função do Lambda recebe uma resposta com código de status HTTP 200 (OK) da chamada da API `WriteGetObjectResponse`, o autor da chamada original enviou a solicitação completa. A resposta da função do Lambda, independentemente de uma exceção ser lançada ou não, é ignorada pelo S3 Object Lambda.
Ao chamar a operação de API `WriteGetObjectResponse`, o Amazon S3 exige a rota e o token de solicitação do contexto do evento. Para obter mais informações, consulte [Formato e uso de contexto de evento](olap-event-context.md).
Os parâmetros de token de roteamento e solicitação são necessários para conectar a resposta `WriteGetObjectResult` com o autor da chamada original. Ainda que sempre seja apropriado repetir respostas 500 (Erro interno do servidor), como o token de solicitação é um token de uso único, as tentativas subsequentes de usá-lo podem resultar em respostas com código de status HTTP 400 (Solicitação inválida). Embora a chamada para `WriteGetObjectResponse` com tokens de roteamento e solicitação não precise ser feita a partir da função do Lambda invocada, ela deve ser feita por uma identidade na mesma conta. A chamada também deverá ser concluída antes que a função do Lambda termine a execução.
## Trabalhar com solicitações `HeadObject` no Lambda
Esta seção pressupõe que seu ponto de acesso do Object Lambda está configurado para chamar a função do Lambda para `HeadObject`. O Lambda receberá uma carga útil JSON que contém uma chave chamada `headObjectContext`. Dentro do contexto, há uma única propriedade chamada `inputS3Url`, que é um URL pré-assinado para o ponto de acesso de suporte para `HeadObject`.
O URL pré-assinado incluirá as seguintes propriedades se elas forem especificadas:
+ `versionId` (nos parâmetros de consulta)
+ `requestPayer` (no cabeçalho de `x-amz-request-payer`)
+ `expectedBucketOwner` (no cabeçalho de `x-amz-expected-bucket-owner`)
Outras propriedades não serão pré-assinadas e, portanto, não serão incluídas. As opções não assinadas enviadas como cabeçalhos podem ser adicionadas manualmente à solicitação ao chamar o URL pré-assinado encontrado nos cabeçalhos de `userRequest`. As opções de criptografia do lado do servidor não são compatíveis com `HeadObject`.
Para ver os parâmetros de URI da sintaxe da solicitação, consulte [https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html) na *Amazon Simple Storage Service API Reference* (Referência da API do Amazon Simple Storage Service).
O exemplo a seguir mostra uma carga útil JSON de entrada do Lambda para `HeadObject`.
```
{
"xAmzRequestId": "requestId",
"**headObjectContext**": {
"**inputS3Url**": "https://my-s3-ap-111122223333.s3-accesspoint.us-east-1.amazonaws.com/example?X-Amz-Security-Token="
},
"configuration": {
"accessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/example-object-lambda-ap",
"supportingAccessPointArn": "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap",
"payload": "{}"
},
"userRequest": {
"url": "https://object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com/example",
"headers": {
"Host": "object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com",
"Accept-Encoding": "identity",
"X-Amz-Content-SHA256": "e3b0c44298fc1example"
}
},
"userIdentity": {
"type": "AssumedRole",
"principalId": "principalId",
"arn": "arn:aws:sts::111122223333:assumed-role/Admin/example",
"accountId": "111122223333",
"accessKeyId": "accessKeyId",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "Wed Mar 10 23:41:52 UTC 2021"
},
"sessionIssuer": {
"type": "Role",
"principalId": "principalId",
"arn": "arn:aws:iam::111122223333:role/Admin",
"accountId": "111122223333",
"userName": "Admin"
}
}
},
"protocolVersion": "1.00"
}
```
Sua função do Lambda deve retornar um objeto JSON que contém os cabeçalhos e os valores que serão retornados para a chamada de `HeadObject`.
O exemplo a seguir mostra a estrutura do JSON de resposta do Lambda para `HeadObject`.
```
{
"statusCode": ; // Required
"errorCode": ;
"errorMessage": ;
"headers": {
"Accept-Ranges": ,
"x-amz-archive-status": ,
"x-amz-server-side-encryption-bucket-key-enabled": ,
"Cache-Control": ,
"Content-Disposition": ,
"Content-Encoding": ,
"Content-Language": ,
"Content-Length": , // Required
"Content-Type": ,
"x-amz-delete-marker": ,
"ETag": ,
"Expires": ,
"x-amz-expiration": ,
"Last-Modified": ,
"x-amz-missing-meta": ,
"x-amz-object-lock-mode": ,
"x-amz-object-lock-legal-hold": ,
"x-amz-object-lock-retain-until-date": ,
"x-amz-mp-parts-count": ,
"x-amz-replication-status": ,
"x-amz-request-charged": ,
"x-amz-restore": ,
"x-amz-server-side-encryption": ,
"x-amz-server-side-encryption-customer-algorithm": ,
"x-amz-server-side-encryption-aws-kms-key-id": ,
"x-amz-server-side-encryption-customer-key-MD5": ,
"x-amz-storage-class": ,
"x-amz-tagging-count": ,
"x-amz-version-id": ,
: , // user-defined metadata
"x-amz-meta-meta1": , // example of the user-defined metadata header, it will need the x-amz-meta prefix
"x-amz-meta-meta2":
...
};
}
```
O exemplo a seguir mostra como usar o URL pré-assinado para preencher sua resposta modificando os valores do cabeçalho conforme necessário antes de retornar o JSON.
------
#### [ Python ]
```
import requests
def lambda_handler(event, context):
print(event)
# Extract the presigned URL from the input.
s3_url = event["headObjectContext"]["inputS3Url"]
# Get the head of the object from S3.
response = requests.head(s3_url)
# Return the error to S3 Object Lambda (if applicable).
if (response.status_code >= 400):
return {
"statusCode": response.status_code,
"errorCode": "RequestFailure",
"errorMessage": "Request to S3 failed"
}
# Store the headers in a dictionary.
response_headers = dict(response.headers)
# This obscures Content-Type in a transformation, it is optional to add
response_headers["Content-Type"] = ""
# Return the headers to S3 Object Lambda.
return {
"statusCode": response.status_code,
"headers": response_headers
}
```
------
## Trabalhar com solicitações `ListObjects` no Lambda
Esta seção pressupõe que seu ponto de acesso do Object Lambda está configurado para chamar a função do Lambda para `ListObjects`. O Lambda receberá a carga JSON com um novo objeto chamado `listObjectsContext`. `listObjectsContext` contém uma única propriedade, `inputS3Url`, que é um URL pré-assinado para o ponto de acesso de suporte para `ListObjects`.
Ao contrário de `GetObject` e `HeadObject`, o URL pré-assinado incluirá as seguintes propriedades se elas forem especificadas:
+ Todos os parâmetros de consulta
+ `requestPayer` (no cabeçalho de `x-amz-request-payer`)
+ `expectedBucketOwner` (no cabeçalho de `x-amz-expected-bucket-owner`)
Para ver os parâmetros de URI da sintaxe da solicitação, consulte [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html) na *Referência da API do Amazon Simple Storage Service*.
**Importante**
Recomendamos que você use a versão mais recente, [ListObjectsV2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html), ao desenvolver aplicações. Para compatibilidade com versões anteriores, o Amazon S3 continua a oferecer suporte a `ListObjects`.
O exemplo a seguir mostra a carga útil JSON de entrada do Lambda para `ListObjects`.
```
{
"xAmzRequestId": "requestId",
"**listObjectsContext**": {
"**inputS3Url**": "https://my-s3-ap-111122223333.s3-accesspoint.us-east-1.amazonaws.com/?X-Amz-Security-Token=",
},
"configuration": {
"accessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/example-object-lambda-ap",
"supportingAccessPointArn": "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap",
"payload": "{}"
},
"userRequest": {
"url": "https://object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com/example",
"headers": {
"Host": "object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com",
"Accept-Encoding": "identity",
"X-Amz-Content-SHA256": "e3b0c44298fc1example"
}
},
"userIdentity": {
"type": "AssumedRole",
"principalId": "principalId",
"arn": "arn:aws:sts::111122223333:assumed-role/Admin/example",
"accountId": "111122223333",
"accessKeyId": "accessKeyId",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "Wed Mar 10 23:41:52 UTC 2021"
},
"sessionIssuer": {
"type": "Role",
"principalId": "principalId",
"arn": "arn:aws:iam::111122223333:role/Admin",
"accountId": "111122223333",
"userName": "Admin"
}
}
},
"protocolVersion": "1.00"
}
```
Sua função do Lambda deve retornar um objeto JSON que contém o código de status, o resultado XML da lista ou as informações de erro que serão retornadas do S3 Object Lambda.
O S3 Object Lambda não processa nem valida `listResultXml`. Em vez disso, o encaminha para o chamador de `ListObjects`. Para `listBucketResult`, o S3 Object Lambda espera que certas propriedades sejam de um tipo específico e lançará exceções se não puder analisá-las. `listResultXml` e `listBucketResult` não podem ser fornecidas ao mesmo tempo.
O exemplo a seguir demonstra como usar o URL pré-assinado para chamar o Amazon S3 e usar o resultado para preencher uma resposta, incluindo a verificação de erros.
------
#### [ Python ]
```
import requests
import xmltodict
def lambda_handler(event, context):
# Extract the presigned URL from the input.
s3_url = event["listObjectsContext"]["inputS3Url"]
# Get the head of the object from Amazon S3.
response = requests.get(s3_url)
# Return the error to S3 Object Lambda (if applicable).
if (response.status_code >= 400):
error = xmltodict.parse(response.content)
return {
"statusCode": response.status_code,
"errorCode": error["Error"]["Code"],
"errorMessage": error["Error"]["Message"]
}
# Store the XML result in a dict.
response_dict = xmltodict.parse(response.content)
# This obscures StorageClass in a transformation, it is optional to add
for item in response_dict['ListBucketResult']['Contents']:
item['StorageClass'] = ""
# Convert back to XML.
listResultXml = xmltodict.unparse(response_dict)
# Create response with listResultXml.
response_with_list_result_xml = {
'statusCode': 200,
'listResultXml': listResultXml
}
# Create response with listBucketResult.
response_dict['ListBucketResult'] = sanitize_response_dict(response_dict['ListBucketResult'])
response_with_list_bucket_result = {
'statusCode': 200,
'listBucketResult': response_dict['ListBucketResult']
}
# Return the list to S3 Object Lambda.
# Can return response_with_list_result_xml or response_with_list_bucket_result
return response_with_list_result_xml
# Converting the response_dict's key to correct casing
def sanitize_response_dict(response_dict: dict):
new_response_dict = dict()
for key, value in response_dict.items():
new_key = key[0].lower() + key[1:] if key != "ID" else 'id'
if type(value) == list:
newlist = []
for element in value:
if type(element) == type(dict()):
element = sanitize_response_dict(element)
newlist.append(element)
value = newlist
elif type(value) == dict:
value = sanitize_response_dict(value)
new_response_dict[new_key] = value
return new_response_dict
```
------
O exemplo a seguir mostra a estrutura do JSON de resposta do Lambda para `ListObjects`.
```
{
"statusCode": ; // Required
"errorCode": ;
"errorMessage": ;
"listResultXml": ; // This can also be Error XML string in case S3 returned error response when calling the pre-signed URL
"listBucketResult": { // listBucketResult can be provided instead of listResultXml, however they can not both be provided in the JSON response
"name": , // Required for 'listBucketResult'
"prefix": ,
"marker": ,
"nextMarker": ,
"maxKeys": , // Required for 'listBucketResult'
"delimiter": ,
"encodingType":
"isTruncated": , // Required for 'listBucketResult'
"contents": [ {
"key": , // Required for 'content'
"lastModified": ,
"eTag": ,
"checksumAlgorithm": , // CRC32, CRC32C, SHA1, SHA256
"size": , // Required for 'content'
"owner": {
"displayName": , // Required for 'owner'
"id": , // Required for 'owner'
},
"storageClass":
},
...
],
"commonPrefixes": [ {
"prefix": // Required for 'commonPrefix'
},
...
],
}
}
```
## Trabalhar com solicitações `ListObjectsV2` no Lambda
Esta seção pressupõe que seu ponto de acesso do Object Lambda está configurado para chamar a função do Lambda para `ListObjectsV2`. O Lambda receberá a carga JSON com um novo objeto chamado `listObjectsV2Context`. `listObjectsV2Context` contém uma única propriedade, `inputS3Url`, que é um URL pré-assinado para o ponto de acesso de suporte para `ListObjectsV2`.
Ao contrário de `GetObject` e `HeadObject`, o URL pré-assinado incluirá as seguintes propriedades se elas forem especificadas:
+ Todos os parâmetros de consulta
+ `requestPayer` (no cabeçalho de `x-amz-request-payer`)
+ `expectedBucketOwner` (no cabeçalho de `x-amz-expected-bucket-owner`)
Para ver os parâmetros de URI da sintaxe da solicitação, consulte [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html) na *Referência da API do Amazon Simple Storage Service*.
O exemplo a seguir mostra a carga útil JSON de entrada do Lambda para `ListObjectsV2`.
```
{
"xAmzRequestId": "requestId",
"**listObjectsV2Context**": {
"**inputS3Url**": "https://my-s3-ap-111122223333.s3-accesspoint.us-east-1.amazonaws.com/?list-type=2&X-Amz-Security-Token=",
},
"configuration": {
"accessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/example-object-lambda-ap",
"supportingAccessPointArn": "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap",
"payload": "{}"
},
"userRequest": {
"url": "https://object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com/example",
"headers": {
"Host": "object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com",
"Accept-Encoding": "identity",
"X-Amz-Content-SHA256": "e3b0c44298fc1example"
}
},
"userIdentity": {
"type": "AssumedRole",
"principalId": "principalId",
"arn": "arn:aws:sts::111122223333:assumed-role/Admin/example",
"accountId": "111122223333",
"accessKeyId": "accessKeyId",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "Wed Mar 10 23:41:52 UTC 2021"
},
"sessionIssuer": {
"type": "Role",
"principalId": "principalId",
"arn": "arn:aws:iam::111122223333:role/Admin",
"accountId": "111122223333",
"userName": "Admin"
}
}
},
"protocolVersion": "1.00"
}
```
Sua função do Lambda deve retornar um objeto JSON que contém o código de status, o resultado XML da lista ou as informações de erro que serão retornadas do S3 Object Lambda.
O S3 Object Lambda não processa nem valida `listResultXml`. Em vez disso, o encaminha para o chamador de `ListObjectsV2`. Para `listBucketResult`, o S3 Object Lambda espera que certas propriedades sejam de um tipo específico e lançará exceções se não puder analisá-las. `listResultXml` e `listBucketResult` não podem ser fornecidas ao mesmo tempo.
O exemplo a seguir demonstra como usar o URL pré-assinado para chamar o Amazon S3 e usar o resultado para preencher uma resposta, incluindo a verificação de erros.
------
#### [ Python ]
```
import requests
import xmltodict
def lambda_handler(event, context):
# Extract the presigned URL from the input.
s3_url = event["listObjectsV2Context"]["inputS3Url"]
# Get the head of the object from Amazon S3.
response = requests.get(s3_url)
# Return the error to S3 Object Lambda (if applicable).
if (response.status_code >= 400):
error = xmltodict.parse(response.content)
return {
"statusCode": response.status_code,
"errorCode": error["Error"]["Code"],
"errorMessage": error["Error"]["Message"]
}
# Store the XML result in a dict.
response_dict = xmltodict.parse(response.content)
# This obscures StorageClass in a transformation, it is optional to add
for item in response_dict['ListBucketResult']['Contents']:
item['StorageClass'] = ""
# Convert back to XML.
listResultXml = xmltodict.unparse(response_dict)
# Create response with listResultXml.
response_with_list_result_xml = {
'statusCode': 200,
'listResultXml': listResultXml
}
# Create response with listBucketResult.
response_dict['ListBucketResult'] = sanitize_response_dict(response_dict['ListBucketResult'])
response_with_list_bucket_result = {
'statusCode': 200,
'listBucketResult': response_dict['ListBucketResult']
}
# Return the list to S3 Object Lambda.
# Can return response_with_list_result_xml or response_with_list_bucket_result
return response_with_list_result_xml
# Converting the response_dict's key to correct casing
def sanitize_response_dict(response_dict: dict):
new_response_dict = dict()
for key, value in response_dict.items():
new_key = key[0].lower() + key[1:] if key != "ID" else 'id'
if type(value) == list:
newlist = []
for element in value:
if type(element) == type(dict()):
element = sanitize_response_dict(element)
newlist.append(element)
value = newlist
elif type(value) == dict:
value = sanitize_response_dict(value)
new_response_dict[new_key] = value
return new_response_dict
```
------
O exemplo a seguir mostra a estrutura do JSON de resposta do Lambda para `ListObjectsV2`.
```
{
"statusCode": ; // Required
"errorCode": ;
"errorMessage": ;
"listResultXml": ; // This can also be Error XML string in case S3 returned error response when calling the pre-signed URL
"listBucketResult": { // listBucketResult can be provided instead of listResultXml, however they can not both be provided in the JSON response
"name": , // Required for 'listBucketResult'
"prefix": ,
"startAfter": ,
"continuationToken": ,
"nextContinuationToken": ,
"keyCount": , // Required for 'listBucketResult'
"maxKeys": , // Required for 'listBucketResult'
"delimiter": ,
"encodingType":
"isTruncated": , // Required for 'listBucketResult'
"contents": [ {
"key": , // Required for 'content'
"lastModified": ,
"eTag": ,
"checksumAlgorithm": , // CRC32, CRC32C, SHA1, SHA256
"size": , // Required for 'content'
"owner": {
"displayName": , // Required for 'owner'
"id": , // Required for 'owner'
},
"storageClass":
},
...
],
"commonPrefixes": [ {
"prefix": // Required for 'commonPrefix'
},
...
],
}
}
```
# Formato e uso de contexto de evento
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
O Amazon S3 Object Lambda fornece contexto sobre a solicitação que está sendo feita no evento passado para a função AWS Lambda. Veja a seguir um exemplo de solicitação. As descrições dos campos são incluídas após o exemplo.
```
{
"xAmzRequestId": "requestId",
"getObjectContext": {
"inputS3Url": "https://my-s3-ap-111122223333.s3-accesspoint.us-east-1.amazonaws.com/example?X-Amz-Security-Token=",
"outputRoute": "io-use1-001",
"outputToken": "OutputToken"
},
"configuration": {
"accessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/example-object-lambda-ap",
"supportingAccessPointArn": "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap",
"payload": "{}"
},
"userRequest": {
"url": "https://object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com/example",
"headers": {
"Host": "object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com",
"Accept-Encoding": "identity",
"X-Amz-Content-SHA256": "e3b0c44298fc1example"
}
},
"userIdentity": {
"type": "AssumedRole",
"principalId": "principalId",
"arn": "arn:aws:sts::111122223333:assumed-role/Admin/example",
"accountId": "111122223333",
"accessKeyId": "accessKeyId",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "Wed Mar 10 23:41:52 UTC 2021"
},
"sessionIssuer": {
"type": "Role",
"principalId": "principalId",
"arn": "arn:aws:iam::111122223333:role/Admin",
"accountId": "111122223333",
"userName": "Admin"
}
}
},
"protocolVersion": "1.00"
}
```
Os seguintes arquivos estão incluídos na solicitação:
+ `xAmzRequestId`: o ID da solicitação do Amazon S3 para essa solicitação. Recomendamos que você registre em log esse valor para ajudar na depuração.
+ `getObjectContext`: os detalhes de entrada e saída para conexões com o Amazon S3 e o S3 Object Lambda.
+ `inputS3Url`: um URL pré-designado que pode ser usado para buscar o objeto original do Amazon S3. O URL é assinado usando a identidade do autor da chamada original, e as permissões desse usuário serão aplicadas quando o URL for usado. Se houver cabeçalhos assinados no URL, a função do Lambda deverá incluí-los na chamada para o Amazon S3, exceto para o cabeçalho `Host`.
+ `outputRoute` – um token de roteamento que é adicionado ao URL do S3 Object Lambda quando a função do Lambda chama `WriteGetObjectResponse`.
+ `outputToken`: um token opaco usado pelo S3 Object Lambda para corresponder a chamada de `WriteGetObjectResponse` com o autor da chamada original.
+ `configuration`: informações de configuração sobre o ponto de acesso do Object Lambda.
+ `accessPointArn`: o nome do recurso da Amazon (ARN) do ponto de acesso do Object Lambda que recebeu essa solicitação.
+ `supportingAccessPointArn`: o ARN do ponto de acesso de suporte especificado na configuração do ponto de acesso do Object Lambda.
+ `payload`: dados personalizados que são aplicados à configuração do ponto de acesso do Object Lambda. O S3 Object Lambda trata esses dados como uma string opaca, portanto, ela pode precisar ser decodificada antes do uso.
+ `userRequest`: informações sobre a chamada original para o S3 Object Lambda.
+ `url`: o URL decodificado da solicitação, conforme recebido pelo S3 Object Lambda, excluindo qualquer parâmetro de consulta relacionado à autorização.
+ `headers`: um mapa de string para strings contendo os cabeçalhos HTTP e seus valores da chamada original, excluindo qualquer cabeçalho relacionado à autorização. Se o mesmo cabeçalho aparecer várias vezes, os valores de cada instância do mesmo cabeçalho serão combinados em uma lista delimitada por vírgulas. O caso dos cabeçalhos originais é retido neste mapa.
+ `userIdentity`: detalhes sobre a identidade que fez a chamada para o S3 Object Lambda. Para obter mais informações, consulte [Registro eventos de dados em logs para trilhas](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html) no *Guia do usuário do AWS CloudTrail*.
+ `type`: o tipo da identidade.
+ `accountId`: a Conta da AWS à qual a identidade pertence.
+ `userName`: o nome amigável da identidade que fez a chamada.
+ `principalId`: o identificador exclusivo da identidade que fez a chamada.
+ `arn`: o ARN da entidade principal que fez a chamada. A última seção do ARN contém o usuário ou função que fez a chamada.
+ `sessionContext`: se a solicitação foi feita com credenciais de segurança temporárias, esse elemento fornece informações sobre a sessão que foi criada para essas credenciais.
+ `invokedBy`: o nome do serviço da AWS service (Serviço da AWS) que fez a solicitação, como o Amazon EC2 Auto Scaling ou AWS Elastic Beanstalk.
+ `sessionIssuer`: se a solicitação foi feita com credenciais de segurança temporárias, esse elemento fornece informações sobre como as credenciais foram obtidas.
+ `protocolVersion`: o ID da versão do contexto fornecido. O formato desse campo é `{Major Version}.{Minor Version}`. Os números de versão menores são sempre números de dois dígitos. Qualquer remoção ou alteração na semântica de um campo exigirá o aumento da versão principal e adesão ativa. O Amazon S3 pode adicionar novos campos a qualquer momento, no qual você pode experimentar um aumento da versão secundária. Devido à natureza das implementações de software, é possível que você veja várias versões secundárias em uso ao mesmo tempo.
# Trabalhar com cabeçalhos Range e partNumber
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Ao trabalhar com objetos grandes no Amazon S3 Object Lambda, você pode usar o cabeçalho HTTP `Range` para baixar um intervalo de bytes especificado de um objeto. É possível usar conexões simultâneas ao Amazon S3 para buscar diferentes escalas de bytes no mesmo objeto. Você também pode usar o parâmetro `partNumber` (inteiro entre 1 e 10.000) que executa uma solicitação em um intervalo para a parte especificada do objeto.
Como há várias maneiras pelas quais você pode querer lidar com uma solicitação que inclua os parâmetros `Range` ou `partNumber`, o S3 Object Lambda não aplica esses parâmetros ao objeto transformado. Em vez disso, sua função do AWS Lambda deve implementar essa funcionalidade conforme necessário para a aplicação.
Para usar os parâmetros `Range` e `partNumber` com o S3 Object Lambda, faça o seguinte:
+ Ative esses parâmetros na configuração do ponto de acesso do Object Lambda.
+ Escreva uma função do Lambda capaz de lidar com solicitações que incluam esses parâmetros.
As etapas a seguir descrevem como fazer isso.
## Etapa 1: configurar o ponto de acesso do Object Lambda
Por padrão, os pontos de acesso do Object Lambda respondem com um erro de código de status HTTP 501 (não implementado) a qualquer solicitação `GetObject` ou `HeadObject` que contém um parâmetro `Range` ou `partNumber` nos cabeçalhos ou nos parâmetros de consulta.
Para permitir que um ponto de acesso do Object Lambda aceite essas solicitações, é necessário incluir `GetObject-Range`, `GetObject-PartNumber`, `HeadObject-Range` ou `HeadObject-PartNumber` na seção `AllowedFeatures` da configuração do ponto de acesso do Object Lambda. Para obter mais informações sobre como atualizar a configuração do ponto de acesso do Object Lambda, consulte [Criar pontos de acesso do Object Lambda](olap-create.md).
## Etapa 2: Implementar o tratamento de `Range` ou `partNumber` na função do Lambda
Quando o ponto de acesso do Object Lambda invoca a função do Lambda com uma solicitação `GetObject` ou `HeadObject` em um intervalo, o parâmetro `Range` ou `partNumber` é incluído no contexto do evento. A localização do parâmetro no contexto do evento depende de qual parâmetro foi usado e de como ele foi incluído na solicitação original para o ponto de acesso do Object Lambda, conforme explicado na tabela a seguir.
| Parâmetro | Localização do contexto do evento |
| --- | --- |
| `Range` (cabeçalho) | `userRequest.headers.Range` |
| `Range` (parâmetro de consulta) | `userRequest.url` (parâmetro de consulta `Range`) |
| `partNumber` | `userRequest.url` (parâmetro de consulta `partNumber`) |
**Importante**
O URL pré-assinado fornecido para o ponto de acesso do Object Lambda não contém o parâmetro `Range` ou `partNumber` da solicitação original. Veja as opções a seguir sobre como lidar com esses parâmetros na função do AWS Lambda.
Depois de extrair o valor `Range` ou `partNumber`, você poderá adotar uma das seguintes abordagens com base nas necessidades da aplicação:
1. **Mapear o `Range` ou `partNumber` solicitado para o objeto transformado (recomendado).**
O jeito mais confiável de lidar com solicitações `Range` e `partNumber` é fazer o seguinte:
+ Recupere o objeto completo do Amazon S3.
+ Transforme o objeto.
+ Aplique os parâmetros `Range` ou `partNumber` solicitados ao objeto transformado.
Para fazer isso, use o URL pré-assinado fornecido para buscar todo o objeto do Amazon S3 e, em seguida, processe o objeto conforme necessário. Para obter um exemplo de função do Lambda que processa o parâmetro `Range` dessa forma, consulte [este exemplo](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration/blob/main/function/nodejs_20_x/src/response/range_mapper.ts) no repositório de exemplos da AWS no GitHub.
1. **Associe o `Range` solicitado ao URL pré-assinado.**
Em alguns casos, a função do Lambda pode associar o `Range` solicitado diretamente ao URL pré-assinado para recuperar apenas parte do objeto do Amazon S3. Essa abordagem será apropriada somente se sua transformação atender a ambos os seguintes critérios:
1. Sua função de transformação pode ser aplicada a intervalos de objetos parciais.
1. Aplicar o parâmetro `Range` antes ou depois da função de transformação ocasiona a transformação do mesmo objeto.
Por exemplo, uma função de transformação que converte todos os caracteres em um objeto codificado em ASCII em maiúsculas atende a ambos os critérios anteriores. A transformação pode ser aplicada a parte de um objeto, e aplicar o parâmetro `Range` ou antes da transformação produz o mesmo resultado que a aplicação do parâmetro após a transformação.
Por outro lado, uma função que inverte os caracteres em um objeto codificado em ASCII não atende a esses critérios. Essa função atende ao critério 1, pois pode ser aplicada a intervalos de objetos parciais. No entanto, ela não atende ao critério 2, porque aplicar o parâmetro `Range` antes da transformação produz resultados diferentes do que a aplicação do parâmetro após a transformação.
Pense em uma solicitação para aplicar a função aos três primeiros caracteres de um objeto com o conteúdo `abcdefg`. Aplicar o parâmetro `Range` antes da transformação recupera somente `abc` e, em seguida, reverte os dados, retornando `cba`. Mas se o parâmetro for aplicado após a transformação, a função recuperará todo o objeto, o reverterá e, em seguida, aplicará o parâmetro `Range`, retornando `gfe`. Como esses resultados são diferentes, essa função não deve aplicar o parâmetro `Range` ao recuperar o objeto do Amazon S3. Em vez disso, ela deve recuperar todo o objeto, executar a transformação e, somente então, aplicar o parâmetro `Range`.
**Atenção**
Em muitos casos, aplicar o parâmetro `Range` ao URL pré-assinado resultará em um comportamento inesperado da função do Lambda ou do cliente solicitante. A menos que você tenha certeza de que seu aplicativo funcionará corretamente ao recuperar apenas um objeto parcial do Amazon S3, recomendamos recuperar e transformar objetos completos, conforme descrito anteriormente na abordagem A.
Se a aplicação atender aos critérios descritos anteriormente na abordagem B, você poderá simplificar a função do AWS Lambda buscando apenas o intervalo de objetos solicitado e executando a transformação nesse intervalo.
O exemplo de código Java a seguir demonstra como fazer o seguinte:
+ Recuperar o cabeçalho `Range` da solicitação `GetObject`.
+ Adicionar o cabeçalho `Range` ao URL pré-assinado que o Lambda pode usar para recuperar o intervalo solicitado do Amazon S3.
```
private HttpRequest.Builder applyRangeHeader(ObjectLambdaEvent event, HttpRequest.Builder presignedRequest) {
var header = event.getUserRequest().getHeaders().entrySet().stream()
.filter(e -> e.getKey().toLowerCase(Locale.ROOT).equals("range"))
.findFirst();
// Add check in the query string itself.
header.ifPresent(entry -> presignedRequest.header(entry.getKey(), entry.getValue()));
return presignedRequest;
}
```
# Uso de funções do Lambda criadas pela AWS
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
A AWS fornece algumas funções pré-criadas do AWS Lambda que você pode usar com o Amazon S3 Object Lambda para detectar e remover informações de identificação pessoal (PII) e descompactar objetos do S3. Essas funções do Lambda estão disponíveis no AWS Serverless Application Repository. Essas funções do Lambda estão disponíveis no Console de gerenciamento da AWS quando você cria um ponto de acesso do Object Lambda.
Para obter mais informações sobre como implantar aplicações de tecnologia sem servidor pelo AWS Serverless Application Repository, consulte [Implantação de aplicações](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-consuming-applications.html) no *Guia do desenvolvedor do AWS Serverless Application Repository*.
**nota**
Os exemplos a seguir só podem ser usados com solicitações `GetObject`.
## Exemplo 1: Controle de acesso de PII
Essa função do Lambda usa o Amazon Comprehend, um serviço de processamento de linguagem natural (PLN) que usa machine learning para encontrar insights e relações no texto. Essa função detecta automaticamente informações de identificação pessoal (PII), como nomes, endereços, datas, números de cartão de crédito e números de previdência social de documentos em seu bucket do Amazon S3. Se você tiver documentos no bucket que incluam PII, poderá configurar a função de controle de acesso de PII para detectar esses tipos de entidade de PII e restringir o acesso a usuários não autorizados.
Para começar, implante a função do Lambda a seguir em sua conta e adicione o nome do recurso da Amazon (ARN) da função na configuração do ponto de acesso do Object Lambda.
Veja o seguinte exemplo de ARN para essa função:
```
arn:aws:serverlessrepo:us-east-1:111122223333:applications/ComprehendPiiAccessControlS3ObjectLambda
```
Você pode adicionar ou exibir essa função no Console de gerenciamento da AWS usando o seguinte link do AWS Serverless Application Repository: [ComprehendPiiAccessControlS3ObjectLambda](https://console.aws.amazon.com/lambda/home#/create/app?applicationId=arn:aws:serverlessrepo:us-east-1:839782855223:applications/ComprehendPiiAccessControlS3ObjectLambda).
Para visualizar essa função no GitHub, consulte [Amazon Comprehend S3 Object Lambda](https://github.com/aws-samples/amazon-comprehend-s3-object-lambdas).
## Exemplo 2: Edição de PII
Essa função do Lambda usa o Amazon Comprehend, um serviço de processamento de linguagem natural (PLN) que usa machine learning para encontrar insights e relações no texto. Essa função remove automaticamente informações de identificação pessoal (PII), como nomes, endereços, datas, números de cartão de crédito e números de previdência social, de documentos em seu bucket do Amazon S3.
Se você tiver documentos em seu bucket que incluam informações como números de cartão de crédito ou informações de contas bancárias, poderá configurar a função do S3 Object Lambda de edição de PII para detectar PII e, em seguida, retornar uma cópia desses documentos nas quais os tipos de entidade de PII estejam editados.
Para começar, implante a função do Lambda a seguir em sua conta e adicione o ARN da função na configuração do ponto de acesso do Object Lambda.
Veja a seguir um exemplo de ARN para essa função:
```
arn:aws:serverlessrepo:us-east-1:111122223333::applications/ComprehendPiiRedactionS3ObjectLambda
```
Você pode adicionar ou exibir essa função no Console de gerenciamento da AWS usando o seguinte link do AWS Serverless Application Repository: [ComprehendPiiRedactionS3ObjectLambda](https://console.aws.amazon.com/lambda/home#/create/app?applicationId=arn:aws:serverlessrepo:us-east-1:839782855223:applications/ComprehendPiiRedactionS3ObjectLambda).
Para visualizar essa função no GitHub, consulte [Amazon Comprehend S3 Object Lambda](https://github.com/aws-samples/amazon-comprehend-s3-object-lambdas).
Para saber mais sobre procedimentos completos para algumas tarefas do S3 Object Lambda em edição de PII, consulte [Tutorial: Detectar e editar dados PII com o S3 Object Lambda e o Amazon Comprehend](tutorial-s3-object-lambda-redact-pii.md).
## Exemplo 3: descompressão
A função `S3ObjectLambdaDecompression` do Lambda pode descompactar objetos armazenados no Amazon S3 em um dos seis formatos de arquivo compactados: `bzip2`, `gzip`, `snappy`, `zlib`, `zstandard` e `ZIP`.
Para começar, implante a função do Lambda a seguir em sua conta e adicione o ARN da função na configuração do ponto de acesso do Object Lambda.
Veja a seguir um exemplo de ARN para essa função:
```
arn:aws:serverlessrepo:us-east-1:111122223333::applications/S3ObjectLambdaDecompression
```
Você pode adicionar ou exibir essa função no Console de gerenciamento da AWS usando o seguinte link do AWS Serverless Application Repository: [S3ObjectLambdaDecompression](https://eu-west-1.console.aws.amazon.com/lambda/home?region=eu-west-1#/create/app?applicationId=arn:aws:serverlessrepo:eu-west-1:123065155563:applications/S3ObjectLambdaDecompression).
Para visualizar essa função no GitHub, consulte [S3 Object Lambda Decompression](https://github.com/aws-samples/amazon-s3-object-lambda-decompression).
# Práticas recomendadas e diretrizes para o S3 Object Lambda
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Ao usar o S3 Object Lambda, siga essas práticas recomendadas e diretrizes para otimizar operações e performance.
**Topics**
+ [
## Trabalhar com o S3 Object Lambda
](#olap-working-with)
+ [
## Serviços da AWS usados em conexão com o S3 Object Lambda
](#olap-services)
+ [
## Cabeçalhos `Range` e `partNumber`
](#olap-managing-range-part)
+ [
## Transformar `expiry-date`
](#olap-console-download)
+ [
## Como trabalhar com a AWS CLI e AWS SDKs
](#olap-cli-sdk)
## Trabalhar com o S3 Object Lambda
O S3 Object Lambda é compatível apenas com o processamento de solicitações `GET`, `LIST` e `HEAD`. Qualquer outra solicitação não invocará AWS Lambda; em vez disso, retornará respostas de API padrão e não transformadas. Você pode criar no máximo 1.000 pontos de acesso do Object Lambda por Conta da AWS por região. A função do AWS Lambda que você usa deve estar nas mesmas Conta da AWS e região que o ponto de acesso do Object Lambda.
O S3 Object Lambda permite transmitir uma resposta completa ao autor da chamada em até 60 segundos. Sua função também está sujeita a cotas padrão do AWS Lambda. Para obter mais informações, consulte [Cotas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) no *Guia do desenvolvedor do AWS Lambda*.
Quando o S3 Object Lambda invoca a função do Lambda especificada, você é responsável por garantir que todos os dados substituídos ou excluídos do Amazon S3 pela função ou aplicação do Lambda especificada sejam intencionais e corretos.
Você só pode usar o S3 Object Lambda para realizar operações em objetos. Você não pode usá-lo para realizar outras operações do Amazon S3, como modificar ou excluir buckets. Para obter uma lista completa das operações do S3 que oferecem suporte a pontos de acesso, consulte [Compatibilidade de pontos de acesso com operações do S3](access-points-service-api-support.md#access-points-operations-support).
Além dessa lista, os pontos de acesso do Object Lambda não são compatíveis com as operações de API [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html), [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) (como origem) e [https://docs.aws.amazon.com/AmazonS3/latest/API/API_SelectObjectContent.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_SelectObjectContent.html).
## Serviços da AWS usados em conexão com o S3 Object Lambda
O S3 Object Lambda conecta Amazon S3, o AWS Lambda e, opcionalmente, outros Serviços da AWS de sua escolha para fornecer objetos relevantes para as aplicações solicitadas. Todos os Serviços da AWS usados com o S3 Object Lambda são regidos por seus respectivos Acordos de Serviço (SLAs). Por exemplo, no caso de qualquer AWS service (Serviço da AWS) não cumprir seu compromisso de serviço, você será elegível para receber um crédito de serviço conforme documentado no SLA do serviço.
## Cabeçalhos `Range` e `partNumber`
Ao trabalhar com objetos grandes, você pode usar o cabeçalho HTTP `Range` para baixar um intervalo de bytes especificado de um objeto. Quando você usa o cabeçalho `Range`, sua solicitação busca somente a parte especificada do objeto. Você também pode usar o cabeçalho `partNumber` para realizar uma solicitação em um intervalo para a parte especificada do objeto.
Para obter mais informações, consulte [Trabalhar com cabeçalhos Range e partNumber](range-get-olap.md).
## Transformar `expiry-date`
Você pode abrir ou baixar objetos transformados do ponto de acesso do Object Lambda no Console de gerenciamento da AWS. Esses objetos devem ser válidos (não expirados). Se sua função do Lambda transformar `expiry-date` dos objetos, você poderá ver objetos expirados que não poderão ser abertos nem baixados. Esse comportamento se aplica somente a objetos restaurados do S3 Glacier Flexible Retrieval e do S3 Glacier Deep Archive.
## Como trabalhar com a AWS CLI e AWS SDKs
Os subcomandos do S3 (`cp`, `mv` e `sync`) da AWS Command Line Interface (AWS CLI) e o uso da classe AWS SDK para Java `TransferManager` não são compatíveis com o S3 Object Lambda.
# Tutoriais do S3 Object Lambda
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Os tutoriais a seguir apresentam procedimentos completos para algumas tarefas do S3 Object Lambda.
Com o S3 Object Lambda você pode adicionar seu próprio código para processar dados recuperados do S3 antes de retorná-los para uma aplicação. Cada um dos tutoriais a seguir modificará os dados à medida que forem recuperados do Amazon S3, sem alterar o objeto existente ou manter várias cópias dos dados. O primeiro tutorial explicará como adicionar uma função do AWS Lambda a uma solicitação GET do S3 para modificar um objeto recuperado do S3. O segundo tutorial demonstra como usar uma função do Lambda predefinida com o Amazon Comprehend para proteger informações de identificação pessoal (PII) recuperadas do S3 antes de retorná-las a uma aplicação. O terceiro tutorial usa o S3 Object Lambda para adicionar uma marca d'água a uma imagem à medida que ela é recuperada do Amazon S3.
+ [Tutorial: Como transformar dados para sua aplicação com o S3 Object Lambda](tutorial-s3-object-lambda-uppercase.md)
+ [Tutorial: Detectar e editar dados PII com o S3 Object Lambda e o Amazon Comprehend](tutorial-s3-object-lambda-redact-pii.md)
+ [Tutorial: Using S3 Object Lambda to dynamically watermark images as they are retrieved (Tutorial: Como usar o S3 Object Lambda para colocar marca d’água em imagens de maneira dinâmica à medida que são recuperadas](https://aws.amazon.com/getting-started/hands-on/amazon-s3-object-lambda-to-dynamically-watermark-images/?ref=docs_gateway/amazons3/olap-tutorials.html)
# Tutorial: Como transformar dados para sua aplicação com o S3 Object Lambda
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Quando você armazena dados no Amazon S3, você pode compartilhá-los facilmente para usar várias aplicações. No entanto, cada aplicação pode ter requisitos de formato de dados exclusivos e pode precisar de modificação ou processamento de seus dados para um caso de uso específico. Por exemplo, um conjunto de dados criado por uma aplicação de comércio eletrônico pode incluir informações de identificação pessoal (PII). Quando os mesmos dados são processados para análise, essas PII não são necessárias e devem ser editadas. No entanto, se o mesmo conjunto de dados for usado para uma campanha de marketing, talvez seja necessário enriquecer os dados com detalhes adicionais, como informações do banco de dados de fidelidade do cliente.
Com o [S3 Object Lambda](https://aws.amazon.com/s3/features/object-lambda) você pode adicionar seu próprio código para processar dados recuperados do S3 antes de retorná-los para uma aplicação. É possível, especificamente, configurar uma função do AWS Lambda e anexá-la a um ponto de acesso do S3 Object Lambda. Quando uma aplicação envia [solicitações GET padrão do S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) por meio do ponto de acesso do S3 Object Lambda, a função do Lambda especificada é invocada para processar quaisquer dados recuperados da fonte de dados subjacente por meio do ponto de acesso de suporte do S3. Depois, o ponto de acesso do S3 Object Lambda retorna o resultado transformado de volta à aplicação. Você pode criar e executar suas próprias funções Lambda personalizadas, adaptando a transformação de dados do S3 Object Lambda ao seu caso de uso específico, tudo sem a necessidade de alterações em suas aplicações.
![\[Este é um diagrama de fluxo de trabalho do S3 Object Lambda.\]](http://docs.aws.amazon.com/pt_br/AmazonS3/latest/userguide/images/ol-example-image-global.png)
**Objetivo**
Neste tutorial, você aprende como adicionar código personalizado a solicitações GET padrão do S3 para modificar o objeto solicitado recuperado do S3 para que o objeto atenda às necessidades do cliente ou aplicação solicitante. Especificamente, você aprende a transformar todo o texto no objeto original armazenado no bucket do S3 em maiúsculas por meio do S3 Object Lambda.
**nota**
Este tutorial usa código Python para transformar os dados. Para ter exemplos de uso de outros AWS SDKs, consulte [Como transformar dados para sua aplicação com o S3 Object Lambda](https://docs.aws.amazon.com/code-library/latest/ug/lambda_example_cross_ServerlessS3DataTransformation_section.html) na Biblioteca de códigos de exemplo de AWS SDK.
**Topics**
+ [
## Pré-requisitos
](#ol-upper-prerequisites)
+ [
## Etapa 1: criar um bucket do S3
](#ol-upper-step1)
+ [
## Etapa 2: fazer upload do arquivo para seu bucket do S3
](#ol-upper-step2)
+ [
## Etapa 3: criar um ponto de acesso do S3
](#ol-upper-step3)
+ [
## Etapa 4: Criar uma função Lambda
](#ol-upper-step4)
+ [
## Etapa 5: configurar uma política do IAM para a função de execução da função Lambda
](#ol-upper-step5)
+ [
## Etapa 6: criar um ponto de acesso do S3 Object Lambda
](#ol-upper-step6)
+ [
## Etapa 7: exibir os dados transformados
](#ol-upper-step7)
+ [
## Etapa 8: limpar
](#ol-upper-step8)
+ [
## Próximas etapas
](#ol-upper-next-steps)
## Pré-requisitos
Antes de começar este tutorial, você deve ter uma Conta da AWS na qual possa fazer login como um usuário do AWS Identity and Access Management (IAM) com permissões corretas. Você também deve instalar a versão 3.8 ou posterior do Python.
**Topics**
+ [
### Criar um usuário do IAM com permissões em sua Conta da AWS (console)
](#ol-upper-prerequisites-account)
+ [
### Instale o Python 3.8 ou posterior em sua máquina local
](#ol-upper-prerequisites-python)
### Criar um usuário do IAM com permissões em sua Conta da AWS (console)
Você pode criar um usuário do IAM para o tutorial. Para concluir este tutorial, o usuário do IAM deve anexar as seguintes políticas do IAM para acessar recursos da AWS e executar ações específicas. Para obter mais informações sobre como criar um usuário do IAM, consulte [Criar usuários do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) no *Guia do usuário do IAM*.
Seu usuário do IAM requer as seguintes políticas:
+ [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonS3FullAccess$jsonEditor): concede permissões a todas as ações do Amazon S3, incluindo permissões para criar e usar um ponto de acesso do Object Lambda.
+ [AWSLambda\$1FullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor): concede permissões a todas as ações do Lambda.
+ [IAMFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor): concede permissões a todas as ações do IAM.
+ [IAMAccessAnalyzerReadOnlyAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/IAMAccessAnalyzerReadOnlyAccess$jsonEditor): concede permissões para ler todas as informações de acesso fornecidas pelo IAM Access Analyzer.
+ [CloudWatchLogsFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/CloudWatchLogsFullAccess$jsonEditor): concede acesso total ao CloudWatch Logs.
**nota**
Para simplificar, este tutorial cria e usa um usuário do IAM. Depois de concluir este tutorial, lembre-se de [Excluir o usuário do IAM](#ol-upper-step8-delete-user). Para uso em produção, recomendamos que você siga as [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*. Uma das práticas recomendadas exige que os usuários humanos usem a federação com um provedor de identidades para acessar a AWS usando credenciais temporárias. Outra prática recomendada é exigir que as workloads usem credenciais temporárias com perfis do IAM para acessar a AWS. Para saber como usar o Centro de Identidade do AWS IAM para criar usuários com credenciais temporárias, consulte [Getting started](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) (Conceitos básicos) no *Guia do usuário do Centro de Identidade do AWS IAM*.
Este tutorial também usa políticas de acesso total gerenciadas pela AWS. Para uso em produção, recomendamos que você conceda apenas as permissões mínimas necessárias para seu caso de uso, de acordo com as [práticas recomendadas de segurança](security-best-practices.md#security-best-practices-prevent).
### Instale o Python 3.8 ou posterior em sua máquina local
Use o procedimento a seguir para instalar o Python 3.8 ou posterior em sua máquina local. Para obter instruções de instalação, consulte a página [Downloading Python](https://wiki.python.org/moin/BeginnersGuide/Download) (Como baixar Python) no *Guia do iniciante do Python*.
1. Abra seu terminal local ou shell e execute o seguinte comando para determinar se o Python já está instalado e, em caso afirmativo, qual versão está instalada.
```
python --version
```
1. Se não tiver o Python 3.8 nem posterior, faça download do [instalador oficial](https://www.python.org/downloads/) do Python 3.8 ou posterior que é adequado para sua máquina local.
1. Execute o instalador clicando duas vezes no arquivo baixado e siga as etapas para concluir a instalação.
Para os **Usuários do Windows**, escolha **Adicionar Python 3.X ao PATH** no assistente de instalação antes de escolher **Instalar agora**.
1. Reinicie o terminal fechando-o e reabrindo-o.
1. Execute o seguinte comando para verificar se o Python 3.8 ou posterior está instalado corretamente.
Para os **usuários do macOS**, execute este comando:
```
python3 --version
```
Para **usuários do Windows**, execute este comando:
```
python --version
```
1. Execute o comando a seguir para verificar se o gerenciador de pacotes pip3 está instalado. Se você vir um número de versão pip e python 3.8 ou posterior na resposta do comando, isso significa que o gerenciador de pacotes pip3 está instalado com sucesso.
```
pip --version
```
## Etapa 1: criar um bucket do S3
Crie um bucket para armazenar os dados originais que você planeja transformar.
**nota**
Os pontos de acesso podem ser anexados a outra fonte de dados, como um volume do Amazon FSx para OpenZFS, mas este tutorial usa um ponto de acesso de suporte anexado a um bucket do S3.
**Para criar um bucket**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Buckets**.
1. Selecione **Create bucket (Criar bucket)**.
A página **Create bucket** (Criar bucket) é aberta.
1. Para **Bucket name** (Nome do bucket), insira um nome para o seu bucket (por exemplo, **tutorial-bucket**).
Para obter mais informações sobre como nomear buckets no Amazon S3, consulte [Regras de nomenclatura de buckets de uso geral](bucketnamingrules.md).
1. Em **Region** (Região), escolha a Região da AWS onde deseja que o bucket resida.
Para obter mais informações sobre a região do bucket, consulte [Visão geral dos buckets de uso geral](UsingBucket.md).
1. Para **Block Public Access settings for this bucket** (Configurações de acesso de bloqueio público para este bucket), mantenha as configurações padrão (**Block *all*public access** (Bloquear todo acesso público) está habilitado).
Recomendamos que você mantenha todas as configurações de acesso de bloqueio público ativadas, a menos que precise desativar uma ou mais delas para seu caso de uso. Para obter mais informações sobre como bloquear o acesso público, consulte [Bloquear o acesso público ao armazenamento do Amazon S3](access-control-block-public-access.md).
1. Mantenha as configurações restantes definidas conforme os padrões.
(Opcional) Se quiser definir configurações de bucket adicionais para o caso de uso específico, consulte [Criar um bucket de uso geral](create-bucket-overview.md).
1. Selecione **Criar bucket**.
## Etapa 2: fazer upload do arquivo para seu bucket do S3
Carregue um arquivo de texto para o bucket do S3. Este arquivo de texto contém os dados originais que você transformará em maiúsculas posteriormente neste tutorial.
Por exemplo, você pode carregar um `tutorial.txt` que contém o seguinte texto:
```
Amazon S3 Object Lambda Tutorial:
You can add your own code to process data retrieved from S3 before
returning it to an application.
```
**Fazer upload de um arquivo para um bucket**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Buckets**.
1. Na lista de **Buckets**, escolha o nome do bucket que você criou na [Etapa 1](#ol-upper-step1) (por exemplo, **tutorial-bucket**) para carregar seu arquivo.
1. Na guia **Objects** (Objetos) do bucket, escolha **Upload** (Fazer upload).
1. Na página **Upload** (Carregar), em **Files and folders** (Arquivos e pastas), escolha **Add files** (Adicionar arquivos).
1. Escolha um arquivo para carregar e, em seguida, escolha **Open** (Abrir). Por exemplo, você pode carregar o exemplo de arquivo `tutorial.txt`mencionado anteriormente.
1. Escolha **Upload** (Carregar).
## Etapa 3: criar um ponto de acesso do S3
Para usar um ponto de acesso do S3 Object Lambda para acessar e transformar os dados originais, você deve criar um ponto de acesso do S3 e associá-lo ao bucket do S3 criado na [Etapa 1](#ol-upper-step1). O ponto de acesso deve estar na mesma Região da AWS que os objetos que você deseja transformar.
Mais adiante neste tutorial, você usará esse ponto de acesso como um ponto de acesso de suporte para o ponto de acesso do Object Lambda.
**Como criar um ponto de acesso**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação, escolha **Access Points** (Pontos de acesso).
1. Na página **Access Points** (Pontos de acesso), escolha **Create access point** (Criar ponto de acesso).
1. No campo **Access point name** (Nome do ponto de acesso), insira o nome (por exemplo, **tutorial-access-point**) para o ponto de acesso.
Para obter mais informações sobre nomenclatura de pontos de acesso, consulte [Regras de nomenclatura para pontos de acesso](access-points-restrictions-limitations-naming-rules.md#access-points-names).
1. No campo **Fonte de dados** insira o nome do bucket criado na [Etapa 1](#ol-upper-step1) (por exemplo, **tutorial-bucket**). O S3 anexa o ponto de acesso a este bucket.
(Opcional) Você pode escolher **Browse S3** (Procurar S3) para navegar e pesquisar buckets na sua conta. Se você escolher **Browse S3** (Procurar S3), selecione o bucket desejado e escolha **Choose path** (Escolher caminho) para preencher o campo **Bucket name** (Nome do bucket) com o nome do bucket.
1. Para **Network origin** (Origem de rede), escolha **Internet**.
Para obter mais informações sobre origens de rede para pontos de acesso, consulte [Criar pontos de acesso restritos a uma nuvem privada virtual](access-points-vpc.md).
1. Por padrão, todas as configurações de bloqueio de acesso público são habilitadas para seu ponto de acesso. Recomendamos manter a opção **Block *all* public access** (Bloquear todo o acesso público) ativada.
Para obter mais informações, consulte [Gerenciar o acesso público a pontos de acesso para buckets de uso geral](access-points-bpa-settings.md).
1. Para todas as outras configurações de ponto de acesso, mantenha as configurações padrão.
(Opcional) Você pode modificar as configurações do ponto de acesso para dar suporte ao caso de uso. Para este tutorial, recomendamos manter as configurações padrão.
(Opcional) Se você precisar gerenciar o acesso ao seu ponto de acesso, você pode especificar uma política de ponto de acesso. Para obter mais informações, consulte [Exemplos de política para pontos de acesso](access-points-policies.md#access-points-policy-examples).
1. Selecione **Create access point** (Criar ponto de acesso).
## Etapa 4: Criar uma função Lambda
Para transformar dados originais, crie uma função do Lambda para usar com o ponto de acesso do S3 Object Lambda.
**Topics**
+ [
### Gravar código de função Lambda e criar um pacote de implantação com um ambiente virtual
](#ol-upper-step4-write-lambda)
+ [
### Crie uma função Lambda com uma função de execução (console)
](#ol-upper-step4-create-function)
+ [
### Implante seu código de função Lambda com arquivos .zip e configure a função Lambda (console)
](#ol-upper-step4-deploy-function)
### Gravar código de função Lambda e criar um pacote de implantação com um ambiente virtual
1. Na sua máquina local, crie uma pasta com o nome da pasta `object-lambda` para que o ambiente virtual use posteriormente neste tutorial.
1. Na pasta `object-lambda`, crie um arquivo com uma função Lambda que altere todo o texto no objeto original para maiúsculas. Por exemplo, você pode usar a seguinte função gravada em Python. Salve esta função em um arquivo chamado `transform.py`.
```
import boto3
import requests
from botocore.config import Config
# This function capitalizes all text in the original object
def lambda_handler(event, context):
object_context = event["getObjectContext"]
# Get the presigned URL to fetch the requested original object
# from S3
s3_url = object_context["inputS3Url"]
# Extract the route and request token from the input context
request_route = object_context["outputRoute"]
request_token = object_context["outputToken"]
# Get the original S3 object using the presigned URL
response = requests.get(s3_url)
original_object = response.content.decode("utf-8")
# Transform all text in the original object to uppercase
# You can replace it with your custom code based on your use case
transformed_object = original_object.upper()
# Write object back to S3 Object Lambda
s3 = boto3.client('s3', config=Config(signature_version='s3v4'))
# The WriteGetObjectResponse API sends the transformed data
# back to S3 Object Lambda and then to the user
s3.write_get_object_response(
Body=transformed_object,
RequestRoute=request_route,
RequestToken=request_token)
# Exit the Lambda function: return the status code
return {'status_code': 200}
```
**nota**
O exemplo anterior da função Lambda carrega todo o objeto solicitado na memória antes de transformá-lo e retorná-lo para o cliente. Como alternativa, você pode transmitir o objeto do S3 para evitar o carregamento do objeto inteiro na memória. Essa abordagem pode ser útil ao trabalhar com objetos grandes. Para obter mais informações sobre streaming de respostas com pontos de acesso do Object Lambda, consulte os exemplos de streaming em [Trabalhar com solicitações `GetObject` no Lambda](olap-writing-lambda.md#olap-getobject-response).
Quando você está gravando uma função do Lambda para uso com um ponto de acesso do S3 Object Lambda, a função é baseada no contexto de evento de entrada que o S3 Object Lambda fornece à função do Lambda. O contexto do evento fornece informações sobre a solicitação que está sendo feita no evento passado do S3 Object Lambda para o Lambda. Ele contém os parâmetros que você usa para criar a função Lambda.
Os campos usados para criar a função Lambda anterior são os seguintes:
O campo `getObjectContext` significa os detalhes de entrada e saída para conexões com o Amazon S3 e S3 Object Lambda. Ele tem os seguintes campos:
+ `inputS3Url`: um URL pré-assinado que a função Lambda pode usar para baixar o objeto original do ponto de acesso de suporte. Usando um URL pré-assinado, a função Lambda não precisa ter permissões de leitura do Amazon S3 para recuperar o objeto original e só pode acessar o objeto processado por cada chamada.
+ `outputRoute`: um token de roteamento que é adicionado ao URL do Object Lambda do S3 quando a função Lambda chama `WriteGetObjectResponse` para enviar de volta o objeto transformado.
+ `outputToken`: um token usado pelo S3 Object Lambda para corresponder à chamada `WriteGetObjectResponse` com o chamador original ao enviar de volta o objeto transformado.
Para obter mais informações sobre todos os campos no contexto de evento, consulte [Formato e uso de contexto de evento](olap-event-context.md) e [Escrever funções do Lambda para pontos de acesso do S3 Object Lambda](olap-writing-lambda.md).
1. No terminal local, insira o seguinte comando para instalar o comando do pacote `virtualenv`:
```
python -m pip install virtualenv
```
1. No terminal local, abra o `object-lambda` que você criou anteriormente e insira o seguinte comando para criar e inicializar um ambiente virtual chamado `venv`.
```
python -m virtualenv venv
```
1. Para ativar o ambiente virtual, insira o seguinte comando para executar o arquivo `activate` da pasta do ambiente:
Para os **usuários do macOS**, execute este comando:
```
source venv/bin/activate
```
Para **usuários do Windows**, execute este comando:
```
.\venv\Scripts\activate
```
Agora, seu prompt de comando é alterado para mostrar **(venv)**, indicando que o ambiente virtual está ativo.
1. Para instalar as bibliotecas necessárias, execute os seguintes comandos linha por linha no ambiente virtual do `venv`.
Esses comandos instalam versões atualizadas das dependências de sua função Lambda `lambda_handler`. Essas dependências são o AWSSDK for Python (Boto3) e o módulo de solicitações.
```
pip3 install boto3
```
```
pip3 install requests
```
1. Para desativar o ambiente virtual, execute o seguinte comando:
```
deactivate
```
1. Para criar um pacote de implantação com as bibliotecas instaladas como um arquivo `.zip` chamado `lambda.zip` na raiz do diretório , execute os comandos a seguir, linha por linha, em seu terminal local.
**dica**
Os comandos a seguir talvez precisem ser ajustados para funcionar em seu ambiente específico. Por exemplo, uma biblioteca pode aparecer em `site-packages`ou em `dist-packages` e a primeira pasta pode ser `lib` ou `lib64`. Além disso, a pasta `python` pode ser nomeada com uma versão Python diferente. Use o comando `pip show` para localizar um pacote específico.
Para **usuários do macOS**, execute estes comandos:
```
cd venv/lib/python3.8/site-packages
```
```
zip -r ../../../../lambda.zip .
```
Para **usuários do Windows**, execute estes comandos:
```
cd .\venv\Lib\site-packages\
```
```
powershell Compress-Archive * ../../../lambda.zip
```
O último comando salva o pacote de implantação na raiz do diretório do `object-lambda`.
1. Adicione o arquivo de código de função `transform.py` à raiz do pacote de implantação.
Para **usuários do macOS**, execute estes comandos:
```
cd ../../../../
```
```
zip -g lambda.zip transform.py
```
Para **usuários do Windows**, execute estes comandos:
```
cd ..\..\..\
```
```
powershell Compress-Archive -update transform.py lambda.zip
```
Depois de concluir esta etapa, você deverá ter seguinte estrutura de diretórios:
```
lambda.zip$
│ transform.py
│ __pycache__
| boto3/
│ certifi/
│ pip/
│ requests/
...
```
### Crie uma função Lambda com uma função de execução (console)
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. No painel de navegação à esquerda, escolha **Functions** (Funções).
1. Escolha **Create function** (Criar função).
1. Escolha **Author from scratch** (Criar do zero).
1. Em **Basic information** (Informações básicas), faça o seguinte:
1. Em **Function name** (Nome da função), insira **tutorial-object-lambda-function**.
1. Para **Runtime** (Tempo de execução), escolha **Python 3.8** ou uma versão posterior.
1. Expandir a seção **Alterar função de execução padrão**. Em **Execution role** (Função de execução), selecione **Create a new role with basic Lambda permissions** (Criar uma função com permissões básicas do Lambda).
Na [Etapa 5](#ol-upper-step5), posteriormente neste tutorial, você anexa o **AmazonS3ObjectLambdaExecutionRolePolicy** a essa função de execução do Lambda.
1. Mantenha as configurações restantes definidas conforme os padrões.
1. Escolha **Create function** (Criar função).
### Implante seu código de função Lambda com arquivos .zip e configure a função Lambda (console)
1. No console do AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/), escolha **Functions** (Funções) no painel de navegação à esquerda.
1. Escolha a função do Lambda que você criou anteriormente (por exemplo, **tutorial-object-lambda-function**).
1. Na página de detalhes da função Lambda, selecione a guia **Code** (Código). Na seção **Code Source** (Origem do código), escolha **Upload from** (Carregar de) e depois **arquivo .zip**.
1. Selecione **Upload** (Carregar) para selecionar seu arquivo `.zip` local.
1. Selecione o arquivo `lambda.zip` que você criou anteriormente e, em seguida, selecione **Open** (Abrir).
1. Escolha **Salvar**.
1. Na seção **Runtime settings** (Configurações do tempo de execução), escolha **Edit** (Editar).
1. Na página **Edit runtime settings** (Editar configurações do tempo de execução), confirme se **Runtime** (Tempo de execução) foi definido como **Python 3.8** ou uma versão posterior.
1. Para informar ao tempo de execução do Lambda qual método de handler em seu código de função Lambda chamar, insira **transform.lambda\$1handler** para **Handler**.
Ao configurar uma função em Python, o valor da configuração do handler é o nome do arquivo e o nome do módulo do handler exportado, separados por um ponto. Por exemplo, `transform.lambda_handler` chama o método `lambda_handler` definido no arquivo `transform.py`.
1. Escolha **Salvar**.
1. (Opcional) Na página de detalhes da função Lambda, escolha a guia **Configuration** (Configuração). No painel de navegação à esquerda, selecione **General configuration** (Configuração geral) e, depois, escolha **Edit** (Editar). No campo **Timeout** (Tempo limite), insira **1** min **0** segundos. Mantenha as configurações restantes definidas, conforme os padrões e escolha **Save** (Salvar).
**Timeout** (Tempo limite) é a quantidade de tempo durante a qual o Lambda permite que uma função seja executada entes de interrompê-la. O padrão é 3 segundos. A duração máxima para uma função Lambda usada pelo S3 Object Lambda é de 60 segundos. O preço é baseado na quantidade de memória configurada e na quantidade de tempo em que o código é executado.
## Etapa 5: configurar uma política do IAM para a função de execução da função Lambda
Para habilitar sua função Lambda para fornecer dados personalizados e cabeçalhos de resposta para o chamador de `GetObject`, a função de execução da função Lambda precisa ter permissões do IAM para chamar a API `WriteGetObjectResponse`.
**Para anexar uma política do IAM à atribuição da função Lambda**
1. No console do AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/), escolha **Functions** (Funções) no painel de navegação à esquerda.
1. Escolha a função que você criou na [Etapa 4](#ol-upper-step4) (por exemplo, **tutorial-object-lambda-function**).
1. Na página de detalhes da função Lambda, selecione a guia **Configuration** (Configuração) e, depois, escolha **Permission** (Permissões) no painel de navegação à esquerda.
1. Em **Execution role** (Função de execução), escolha o link do **Role name** (Nome da função). O console do IAM é aberto.
1. Na página **Summary** (Resumo) do console do IAM para o perfil de execução da função do Lambda, escolha a guia **Permissions** (Permissões). Depois, no menu **Add Permissions** (Adicionar permissões), escolha **Attach policies** (Anexar políticas).
1. Na página **Attach Permissions** (Anexar permissões), insira **AmazonS3ObjectLambdaExecutionRolePolicy** na caixa de pesquisa para filtrar a lista de políticas. Marque a caixa de seleção ao lado do nome da política **AmazonS3ObjectLambdaExecutionRolePolicy**.
1. Escolha **Anexar políticas**.
## Etapa 6: criar um ponto de acesso do S3 Object Lambda
Um ponto de acesso do S3 Object Lambda fornece a flexibilidade de chamar uma função do Lambda diretamente de uma solicitação GET do S3 para que a função possa processar dados recuperados de um ponto de acesso do S3. Ao criar e configurar um ponto de acesso do S3 Object Lambda, você deve especificar a função do Lambda para chamar e fornecer o contexto do evento no formato JSON como parâmetros personalizados para o Lambda usar.
**Para criar um ponto de acesso do S3 Object Lambda**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Object Lambda access points** (Pontos de acesso do Object Lambda).
1. Na página **Object Lambda Access Points** (Pontos de acesso do Object Lambda), escolha **Create Object Lambda Access Point** (Criar ponto de acesso do Object Lambda).
1. Para **Nome do Ponto de acesso Lambda do objeto**, informe o nome que você deseja usar para o ponto de acesso Lambda do objeto (por exemplo, **tutorial-object-lambda-accesspoint**).
1. Para **Supporting Access Point** (Ponto de acesso de suporte), informe ou procure o ponto de acesso padrão criado na [Etapa 3](#ol-upper-step3) (por exemplo, **tutorial-access-point**) e, em seguida, escolha **Choose supporting Access Point** (Escolher ponto de acesso de suporte).
1. Para recuperar objetos do bucket do S3 para que a função do Lambda processe, selecione **GetObject** em **S3 APIs** (APIs do S3).
1. Para **Invoke Lambda function** (Chamar função Lambda), você pode escolher qualquer uma das duas opções a seguir para este tutorial.
+ Selecione **Escolha entre as funções da sua conta** e escolha a função do Lambda que você criou na [Etapa 4](#ol-upper-step4) (por exemplo, **tutorial-object-lambda-function**) da lista suspensa **Função do Lambda**.
+ Escolha **Enter ARN** (Inserir ARN) e depois informe o Nome do recurso da Amazon (ARN) da função Lambda que você criou na [Etapa 4](#ol-upper-step4).
1. Para **Lambda function version** (Versão da função Lambda), escolha **\$1LATEST** (a versão mais recente da função Lambda que você criou na [Etapa 4](#ol-upper-step4)).
1. (Opcional) Se precisar da função Lambda para reconhecer e processar solicitações GET com cabeçalhos de intervalo e número de peça, selecione **Lambda function supports requests using range** (A função Lambda suporta solicitações usando intervalo) e **Lambda function supports requests using part numbers** (A função Lambda suporta solicitações usando números de parte). Caso contrário, desmarque essas duas caixas de seleção.
Para obter mais informações sobre como usar números de intervalo ou de parte com o S3 Object Lambda, consulte [Trabalhar com cabeçalhos Range e partNumber](range-get-olap.md).
1. (Opcional) Em **Payload - *optional*** (Carga útil - opcional), adicione um texto JSON para fornecer informações adicionais à sua função Lambda.
Uma carga útil é um texto JSON opcional que você pode fornecer à sua função do Lambda como entrada para todas as chamadas provenientes de um ponto de acesso do S3 Object Lambda específico. Para personalizar os comportamentos de vários pontos de acesso Lambda do objeto que chamam a mesma função do Lambda, você pode configurar cargas úteis com diferentes parâmetros, estendendo, assim, a flexibilidade da função do Lambda.
Para obter mais informações sobre carga útil, consulte [Formato e uso de contexto de evento](olap-event-context.md).
1. (Opcional) Em **Métricas de solicitação – *opcional***, escolha **Desabilitar** ou **Habilitar** para adicionar o monitoramento do Amazon S3 ao ponto de acesso do Object Lambda. As métricas de solicitação são cobradas na taxa padrão do Amazon CloudWatch. Para obter mais informações, consulte [Preço do CloudWatch.](https://aws.amazon.com/cloudwatch/pricing/)
1. Em **Object Lambda Access Point policy - *optional*** (Política do ponto de acesso do Object Lambda - opcional), mantenha a configuração padrão.
(Opcional) Você pode definir uma política de recursos. Essa política de recursos concede permissão da API `GetObject` para usar o ponto de acesso do Object Lambda especificado.
1. Mantenha as configurações restantes definidas conforme os padrões e escolha **Create Object Lambda Access Point** (Criar ponto de acesso do Object Lambda).
## Etapa 7: exibir os dados transformados
Agora, o S3 Object Lambda está pronto para transformar seus dados para seu caso de uso. Neste tutorial, o S3 Object Lambda transforma todo o texto em seu objeto em maiúsculas.
**Topics**
+ [
### Exibir os dados transformados no ponto de acesso do S3 Object Lambda
](#ol-upper-step7-check-data)
+ [
### Execute um script Python para imprimir os dados originais e transformados
](#ol-upper-step7-python-print)
### Exibir os dados transformados no ponto de acesso do S3 Object Lambda
Quando você solicita para recuperar um arquivo por meio do ponto de acesso do S3 Object Lambda, você faz uma chamada de API `GetObject` para o S3 Object Lambda. O S3 Object Lambda chama a função Lambda para transformar seus dados e, em seguida, retorna os dados transformados como a resposta à chamada de API de `GetObject` do S3 padrão.
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Object Lambda access points** (Pontos de acesso do Object Lambda).
1. Na página **Pontos de acesso do Object Lambda**, escolha o ponto de acesso do S3 Object Lambda que você criou na [Etapa 6](#ol-upper-step6) (por exemplo, **tutorial-object-lambda-accesspoint**).
1. Na guia **Objetos** do ponto de acesso do S3 Object Lambda, selecione o arquivo que tem o mesmo nome (por exemplo, `tutorial.txt`) daquele que você carregou no bucket do S3 na [Etapa 2](#ol-upper-step2).
Esse arquivo deve conter todos os dados transformados.
1. Para exibir os dados transformados, escolha **Open** (Abrir) ou **Download** (Baixar).
### Execute um script Python para imprimir os dados originais e transformados
Você pode usar o S3 Object Lambda com suas aplicações existentes. Para fazer isso, atualize a configuração da aplicação para usar o novo ARN do ponto de acesso do S3 Object Lambda criado na [Etapa 6](#ol-upper-step6) para recuperar dados do S3.
O exemplo de script Python a seguir imprime os dados originais do bucket do S3 e os dados transformados do ponto de acesso do S3 Object Lambda.
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Object Lambda access points** (Pontos de acesso do Object Lambda).
1. Na página **Pontos de acesso Lambda de objeto**, selecione o botão de opção à esquerda do ponto de acesso do S3 Object Lambda que você criou na [Etapa 6](#ol-upper-step6) (por exemplo, **tutorial-object-lambda-accesspoint**).
1. Escolha **Copy ARN** (Copiar ARN).
1. Salve o ARN para uso mais tarde.
1. Grave um script Python na máquina local para imprimir os dados originais (por exemplo, `tutorial.txt`) do bucket do S3 e os dados transformados (por exemplo, `tutorial.txt`) do ponto de acesso do S3 Object Lambda). Você pode usar o seguinte script de exemplo:
```
import boto3
from botocore.config import Config
s3 = boto3.client('s3', config=Config(signature_version='s3v4'))
def getObject(bucket, key):
objectBody = s3.get_object(Bucket = bucket, Key = key)
print(objectBody["Body"].read().decode("utf-8"))
print("\n")
print('Original object from the S3 bucket:')
# Replace the two input parameters of getObject() below with
# the S3 bucket name that you created in Step 1 and
# the name of the file that you uploaded to the S3 bucket in Step 2
getObject("tutorial-bucket",
"tutorial.txt")
print('Object transformed by S3 Object Lambda:')
# Replace the two input parameters of getObject() below with
# the ARN of your S3 Object Lambda Access Point that you saved earlier and
# the name of the file with the transformed data (which in this case is
# the same as the name of the file that you uploaded to the S3 bucket
# in Step 2)
getObject("arn:aws:s3-object-lambda:us-west-2:111122223333:accesspoint/tutorial-object-lambda-accesspoint",
"tutorial.txt")
```
1. Salve seu script Python com um nome personalizado (por exemplo, `tutorial_print.py`) na pasta (por exemplo, `object-lambda`) que você criou na [Etapa 4](#ol-upper-step4) na sua máquina local.
1. No terminal local, execute o seguinte comando da raiz do diretório (por exemplo, `object-lambda`) que você criou na [Etapa 4](#ol-upper-step4).
```
python3 tutorial_print.py
```
Você deve ver os dados originais e os dados transformados (todo o texto em maiúsculas) através do terminal. Por exemplo, você deve ver algo parecido com o texto a seguir.
```
Original object from the S3 bucket:
Amazon S3 Object Lambda Tutorial:
You can add your own code to process data retrieved from S3 before
returning it to an application.
Object transformed by S3 Object Lambda:
AMAZON S3 OBJECT LAMBDA TUTORIAL:
YOU CAN ADD YOUR OWN CODE TO PROCESS DATA RETRIEVED FROM S3 BEFORE
RETURNING IT TO AN APPLICATION.
```
## Etapa 8: limpar
Se você transformou seus dados por meio do S3 Object Lambda apenas como um exercício de aprendizado, exclua os recursos da AWS que você alocou para que não haja mais encargos.
**Topics**
+ [
### Excluir o ponto de acesso do Object Lambda
](#ol-upper-step8-delete-olap)
+ [
### Exclua o ponto de acesso do S3
](#ol-upper-step8-delete-ap)
+ [
### Exclua a função de execução de sua função Lambda
](#ol-upper-step8-delete-lambda-role)
+ [
### Excluir a função Lambda
](#ol-upper-step8-delete-lambda-function)
+ [
### Excluir o grupo de logs do CloudWatch
](#ol-upper-step8-delete-cloudwatch)
+ [
### Exclua o arquivo original no bucket de origem do S3
](#ol-upper-step8-delete-file)
+ [
### Exclua o bucket de origem do S3
](#ol-upper-step8-delete-bucket)
+ [
### Excluir o usuário do IAM
](#ol-upper-step8-delete-user)
### Excluir o ponto de acesso do Object Lambda
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Object Lambda access points** (Pontos de acesso do Object Lambda).
1. Na página **Pontos de acesso Lambda de objeto**, selecione o botão de opção à esquerda do ponto de acesso do S3 Object Lambda que você criou na [Etapa 6](#ol-upper-step6) (por exemplo, **tutorial-object-lambda-accesspoint**).
1. Escolha **Excluir**.
1. Confirme se deseja excluir o ponto de acesso do Lambda, inserindo o nome no campo de texto exibido e escolha **Excluir**.
### Exclua o ponto de acesso do S3
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação, escolha **Access Points** (Pontos de acesso).
1. Navegue até o ponto de acesso que você criou na [Etapa 3](#ol-upper-step3) (por exemplo, **tutorial-access-point**) e escolha o botão de opção ao lado do nome do ponto de acesso.
1. Escolha **Excluir**.
1. Confirme se deseja excluir o ponto de acesso inserindo o nome no campo de texto exibido e escolha **Delete** (Excluir).
### Exclua a função de execução de sua função Lambda
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. No painel de navegação à esquerda, escolha **Functions** (Funções).
1. Escolha a função que você criou na [Etapa 4](#ol-upper-step4) (por exemplo, **tutorial-object-lambda-function**).
1. Na página de detalhes da função Lambda, selecione a guia **Configuration** (Configuração) e, depois, escolha **Permission** (Permissões) no painel de navegação à esquerda.
1. Em **Execution role** (Função de execução), escolha o link do **Role name** (Nome da função). O console do IAM é aberto.
1. Na página **Summary** (Resumo) do console do IAM da função de execução da função Lambda, selecione **Delete role** (Excluir função).
1. Na caixa de diálogo **Delete role** (Excluir função), selecione **Yes, delete** (Sim, excluir).
### Excluir a função Lambda
1. No console do AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/), escolha **Functions** (Funções) no painel de navegação à esquerda.
1. Marque a caixa de seleção à esquerda do nome da função que você criou na [Etapa 4](#ol-upper-step4) (por exemplo, **tutorial-object-lambda-function**).
1. Escolha **Ações** e, em seguida, escolha **Excluir**.
1. Na caixa de diálogo **Delete function** (Excluir função), escolha **Delete** (Excluir).
### Excluir o grupo de logs do CloudWatch
1. Abra o console do CloudWatch em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação esquerdo, escolha **Log groups** (Grupos de log).
1. Localize o grupo de logs cujo nome termina com a função Lambda que você criou na [Etapa 4](#ol-upper-step4) (por exemplo, **tutorial-object-lambda-function**).
1. Marque a caixa de seleção à esquerda do nome do grupo de logs.
1. Escolha **Actions** (Ações) e **Delete log group(s)** (Excluir grupo(s) de log).
1. Na caixa de diálogo **Delete log group(s)** (Excluir grupo(s) de logs), escolha **Delete** (Excluir).
### Exclua o arquivo original no bucket de origem do S3
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Buckets**.
1. Na lista **Bucket name** (Nome do bucket), escolha o nome do bucket para o qual você carregou o arquivo original na [Etapa 2](#ol-upper-step2) (por exemplo, **tutorial-bucket**).
1. Marque a caixa de seleção à esquerda do nome do objeto que você deseja excluir (por exemplo, `tutorial.txt`).
1. Escolha **Excluir**.
1. Na página **Delete objects** (Excluir objetos) na seção **Permanently delete objects?** (Excluir objetos permanentemente?), confirme se deseja excluir este objeto informando **permanently delete** na caixa de texto.
1. Escolha **Delete objects** (Excluir objetos).
### Exclua o bucket de origem do S3
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Buckets**.
1. Na lista de **Buckets**, escolha o botão de opção ao lado do nome do bucket que você criou na [Etapa 1](#ol-upper-step1) (por exemplo, **tutorial-bucket**).
1. Escolha **Excluir**.
1. Na página **Delete bucket** (Excluir bucket), confirme se deseja excluir o bucket inserindo o nome do bucket no campo de texto e escolha **Delete bucket** (Excluir bucket).
### Excluir o usuário do IAM
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação esquerdo, escolha **Users** (Usuários) e marque a caixa de seleção ao lado do nome do usuário que você deseja excluir.
1. Na parte superior da página, escolha **Delete** (Excluir).
1. Na caixa de diálogo **Delete *user name*?** (Excluir nome de usuário?), insira o nome de usuário no campo de entrada de texto para confirmar a exclusão do usuário. Escolha **Excluir**.
## Próximas etapas
Após concluir este tutorial, você pode personalizar a função Lambda para o caso de uso para modificar os dados retornados por solicitações S3 GET padrão.
Veja a seguir uma lista de casos de uso comuns para o S3 Object Lambda:
+ Mascaramento de dados confidenciais para segurança e conformidade.
Para obter mais informações, consulte [Tutorial: Detectar e editar dados PII com o S3 Object Lambda e o Amazon Comprehend](tutorial-s3-object-lambda-redact-pii.md).
+ Filtragem de determinadas linhas de dados para fornecer informações específicas.
+ Aumento de dados com informações de outros serviços ou bancos de dados.
+ Conversão entre formatos de dados, como conversão de XML em JSON para compatibilidade de aplicações.
+ Compactação ou descompactação de arquivos enquanto eles estão sendo baixados.
+ Redimensionamento e marcação d'água de imagens.
Para obter mais informações, consulte [Tutorial: Using S3 Object Lambda to dynamically watermark images as they are retrieved](https://aws.amazon.com/getting-started/hands-on/amazon-s3-object-lambda-to-dynamically-watermark-images/?ref=docs_gateway/amazons3/tutorial-s3-object-lambda-uppercase.html) (Tutorial: Como usar o S3 Object Lambda para colocar marca d’água em imagens de maneira dinâmica à medida que são recuperadas).
+ Implementação de regras de autorização personalizadas para acessar dados.
Para obter mais informações sobre o S3 Object Lambda, consulte [Transformar objetos com o S3 Object Lambda](transforming-objects.md).
# Tutorial: Detectar e editar dados PII com o S3 Object Lambda e o Amazon Comprehend
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
Quando você estiver usando o Amazon S3 para conjuntos de dados compartilhados para várias aplicações e os usuários acessarem, é importante restringir informações privilegiadas, como informações de identificação pessoal (PII) apenas para entidades autorizadas. Por exemplo, quando uma aplicação de marketing usa alguns dados contendo PII, ela pode precisar primeiro mascarar dados PII para atender aos requisitos de privacidade de dados. Além disso, quando um aplicação de análise usa um conjunto de dados de inventário de ordem de produção, talvez seja necessário primeiro editar as informações do cartão de crédito do cliente para evitar perdas não intencionais de dados.
Com o [S3 Object Lambda](https://aws.amazon.com/s3/features/object-lambda) e uma função do AWS Lambda pré-construída, habilitada pelo Amazon Comprehend, você pode proteger dados de PII recuperados do S3 antes de retorná-los para uma aplicação. Especificamente, é possível usar a [função do Lambda](https://aws.amazon.com/lambda/) pré-criada como função de edição e anexá-la a um ponto de acesso do S3 Object Lambda. Quando uma aplicação (por exemplo, uma aplicação de analytics) envia [solicitações GET padrão do S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html), essas solicitações feitas por meio do ponto de acesso do S3 Object Lambda invocam a função do Lambda de edição predefinida para detectar e editar dados de PII recuperados de uma fonte de dados subjacente por meio de um ponto de acesso de suporte do S3. Depois, o ponto de acesso do S3 Object Lambda retorna o resultado editado de volta à aplicação.
![\[Este é um diagrama de fluxo de trabalho do S3 Object Lambda.\]](http://docs.aws.amazon.com/pt_br/AmazonS3/latest/userguide/images/ol-comprehend-image-global.png)
No processo, a função do Lambda pré-criada usa o [Amazon Comprehend](https://aws.amazon.com/comprehend/), um serviço de processamento de linguagem natural (PNL) para registrar variações em como as PII são representadas, independentemente de como as PII existem no texto (por exemplo, numericamente ou uma combinação de palavras e números). O Amazon Comprehend pode até usar o contexto no texto para entender se um número de quatro dígitos é um PIN, os últimos quatro números de um número de Seguridade Social (SSN) ou um ano. O Amazon Comprehend processa qualquer arquivo de texto no formato UTF-8 e pode proteger as PII em escala sem afetar a precisão. Para obter mais informações, consulte [O que é Amazon Comprehend?](https://docs.aws.amazon.com/comprehend/latest/dg/what-is.html) no *Guia do desenvolvedor do Amazon Comprehend*.
**Objetivo**
Neste tutorial, você aprenderá a usar o S3 Object Lambda com a função Lambda pré-criada `ComprehendPiiRedactionS3ObjectLambda`. Essa função usa o Amazon Comprehend para detectar entidades de PII. Em seguida, ele edita essas entidades substituindo-as por asteriscos. Ao editar as PII, você oculta dados sigilosos, o que pode ajudar com segurança e conformidade.
Você também aprende a usar e configurar uma função AWS Lambda pré-criada no [AWS Serverless Application Repository](https://aws.amazon.com/serverless/serverlessrepo/) para trabalhar em conjunto com o S3 Object Lambda para facilitar a implantação.
**Topics**
+ [
## Pré-requisitos: criar um usuário do IAM com permissões
](#ol-pii-prerequisites)
+ [
## Etapa 1: criar um bucket do S3
](#ol-pii-step1)
+ [
## Etapa 2: fazer upload do arquivo para seu bucket do S3
](#ol-pii-step2)
+ [
## Etapa 3: criar um ponto de acesso do S3
](#ol-pii-step3)
+ [
## Etapa 4: configurar e implantar uma função Lambda pré-construída
](#ol-pii-step4)
+ [
## Etapa 5: criar um ponto de acesso do S3 Object Lambda
](#ol-pii-step5)
+ [
## Etapa 6: usar o ponto de acesso do S3 Object Lambda para recuperar o arquivo editado
](#ol-pii-step6)
+ [
## Etapa 7: limpar
](#ol-pii-step7)
+ [
## Próximas etapas
](#ol-pii-next-steps)
## Pré-requisitos: criar um usuário do IAM com permissões
Antes de iniciar este tutorial, você deve ter uma conta da AWS na qual possa fazer login como um usuário do AWS Identity and Access Management (usuário do IAM) com permissões corretas.
Você pode criar um usuário do IAM para o tutorial. Para concluir este tutorial, o usuário do IAM deve anexar as seguintes políticas do IAM para acessar recursos da AWS e executar ações específicas.
**nota**
Para simplificar, este tutorial cria e usa um usuário do IAM. Depois de concluir este tutorial, lembre-se de [Excluir o usuário do IAM](#ol-pii-step8-delete-user). Para uso em produção, recomendamos que você siga as [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*. Uma das práticas recomendadas exige que os usuários humanos usem a federação com um provedor de identidades para acessar a AWS usando credenciais temporárias. Outra prática recomendada é exigir que as workloads usem credenciais temporárias com perfis do IAM para acessar a AWS. Para saber como usar o Centro de Identidade do AWS IAM para criar usuários com credenciais temporárias, consulte [Getting started](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) (Conceitos básicos) no *Guia do usuário do Centro de Identidade do AWS IAM*.
Este tutorial usa políticas de acesso total. Para uso em produção, recomendamos que você conceda apenas as permissões mínimas necessárias para seu caso de uso, de acordo com as [práticas recomendadas de segurança](security-best-practices.md#security-best-practices-prevent).
Seu usuário do IAM requer as seguintes políticas gerenciadas pela AWS:
+ [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonS3FullAccess$jsonEditor): concede permissões a todas as ações do Amazon S3, incluindo permissões para criar e usar um ponto de acesso do Object Lambda.
+ [AWSLambda\$1FullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor): concede permissões a todas as ações do Lambda.
+ [AWSCloudFormationFullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AWSCloudFormationFullAccess$serviceLevelSummary): concede permissões a todas as ações do AWS CloudFormation.
+ [IAMFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor): concede permissões a todas as ações do IAM.
+ [IAMAccessAnalyzerReadOnlyAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/IAMAccessAnalyzerReadOnlyAccess$jsonEditor): concede permissões para ler todas as informações de acesso fornecidas pelo IAM Access Analyzer.
Você pode anexar diretamente essas políticas existentes ao criar um usuário do IAM. Para obter mais informações sobre como criar um usuário do IAM, consulte [Criar usuários do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) no *Guia do usuário do IAM*.
Além disso, seu usuário do IAM requer uma política gerenciada pelo cliente. Para conceder permissões de usuário do IAM a todos os recursos e ações do AWS Serverless Application Repository, você deve criar uma política do IAM e anexá-la ao usuário do IAM.
**Para criar e anexar uma política do IAM para um usuário do IAM**
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação à esquerda, escolha **Políticas**.
1. Escolha **Create policy** (Criar política).
1. Na guia **Visual editor** (Editor visual) de **Service** (Serviço), selecione **Choose a service** (Escolher um serviço). Em seguida, escolha **Serverless Application Repository** (Repositório de aplicações sem servidor).
1. Para **Actions** (Ações), em **Manual actions** (Ações manuais), selecione **All Serverless Application Repository actions (serverlessrepo:\$1)** (Todas as ações do Serverless Application Repository (serverlessrepo: \$1)) para este tutorial.
Como uma prática recomendada de segurança, você deve conceder permissões somente para as ações e os recursos dos quais um usuário precisa, com base no seu caso de uso. Para obter mais informações, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
1. Para **Resources** (Recursos), escolha **All resources** (Todos os recursos) para este tutorial.
Como prática recomendada, você deve definir permissões somente para recursos específicos em contas específicas. Como alternativa, você pode conceder menos privilégios usando chaves de condição. Para obter mais informações, consulte [Grant least privilege](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) (Conceder privilégio mínimo) no *Guia do usuário do IAM*.
1. Escolha **Próximo: tags**.
1. Selecione **Next: Review** (Próximo: revisar).
1. Na página **Revisar política**, insira um **nome** (por exemplo, **tutorial-serverless-application-repository**) e uma **descrição** (opcional) para a política que você está criando. Revise o resumo da política para assegurar-se de ter concedido as permissões que pretendia e, em seguida, escolha **Create policy** (Criar política) para salvar sua nova política.
1. No painel de navegação à esquerda, escolha **Usuários**. Em seguida, escolha o usuário do IAM para este tutorial.
1. Na página **Summary** (Resumo) do usuário escolhido, escolha a guia **Permissions** (Permissões) e escolha **Add permissions** (Adicionar permissões).
1. Em **Grant permissions** (Conceder permissões), escolha **Attach existing policies directly** (Anexar políticas existentes diretamente).
1. Marque a caixa de seleção ao lado da política que você acabou de criar (por exemplo, **tutorial-serverless-application-repository**) e, depois, escolha **Next: Review** (Próximo: Revisar).
1. Em **Permissions summary** (Resumo de permissões), revise o resumo para se certificar de que anexou a política que pretendia. Em seguida, selecione **Add permissions** (Adicionar permissões).
## Etapa 1: criar um bucket do S3
Crie um bucket para armazenar os dados originais que você planeja transformar.
**nota**
Os pontos de acesso podem ser anexados a outra fonte de dados, como um volume do Amazon FSx para OpenZFS, mas este tutorial usa um ponto de acesso de suporte anexado a um bucket do S3.
**Para criar um bucket**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Buckets**.
1. Selecione **Create bucket (Criar bucket)**.
A página **Create bucket** (Criar bucket) é aberta.
1. Para **Bucket name** (Nome do bucket), insira um nome para o seu bucket (por exemplo, **tutorial-bucket**).
Para obter mais informações sobre como nomear buckets no Amazon S3, consulte [Regras de nomenclatura de buckets de uso geral](bucketnamingrules.md).
1. Em **Region** (Região), escolha a Região da AWS onde deseja que o bucket resida.
Para obter mais informações sobre a região do bucket, consulte [Visão geral dos buckets de uso geral](UsingBucket.md).
1. Para **Block Public Access settings for this bucket** (Configurações de acesso de bloqueio público para este bucket), mantenha as configurações padrão (**Block *all*public access** (Bloquear todo acesso público) está habilitado).
Recomendamos que você mantenha todas as configurações de acesso de bloqueio público ativadas, a menos que precise desativar uma ou mais delas para seu caso de uso. Para obter mais informações sobre como bloquear o acesso público, consulte [Bloquear o acesso público ao armazenamento do Amazon S3](access-control-block-public-access.md).
1. Mantenha as configurações restantes definidas conforme os padrões.
(Opcional) Se quiser definir configurações de bucket adicionais para o caso de uso específico, consulte [Criar um bucket de uso geral](create-bucket-overview.md).
1. Selecione **Criar bucket**.
## Etapa 2: fazer upload do arquivo para seu bucket do S3
Carregue um arquivo de texto contendo dados de PII conhecidos de vários tipos, como nomes, informações bancárias, números de telefone e SSNs, para o bucket do S3 como os dados originais dos quais você editará as PII posteriormente neste tutorial.
Por exemplo, você pode carregar seguindo o arquivo `tutorial.txt`. Este é um exemplo de arquivo de entrada do Amazon Comprehend.
```
Hello Zhang Wei, I am John. Your AnyCompany Financial Services,
LLC credit card account 1111-0000-1111-0008 has a minimum payment
of $24.53 that is due by July 31st. Based on your autopay settings,
we will withdraw your payment on the due date from your
bank account number XXXXXX1111 with the routing number XXXXX0000.
Your latest statement was mailed to 100 Main Street, Any City,
WA 98121.
After your payment is received, you will receive a confirmation
text message at 206-555-0100.
If you have questions about your bill, AnyCompany Customer Service
is available by phone at 206-555-0199 or
email at support@anycompany.com.
```
**Fazer upload de um arquivo para um bucket**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Buckets**.
1. Na lista de **Buckets**, escolha o nome do bucket que você criou na [Etapa 1](#ol-pii-step1) (por exemplo, **tutorial-bucket**) para carregar seu arquivo.
1. Na guia **Objects** (Objetos) do bucket, escolha **Upload** (Fazer upload).
1. Na página **Upload** (Carregar), em **Files and folders** (Arquivos e pastas), escolha **Add files** (Adicionar arquivos).
1. Escolha um arquivo para carregar e, em seguida, escolha **Open** (Abrir). Por exemplo, você pode carregar o exemplo de arquivo `tutorial.txt`mencionado anteriormente.
1. Escolha **Upload** (Carregar).
## Etapa 3: criar um ponto de acesso do S3
Para usar um ponto de acesso do S3 Object Lambda para acessar e transformar os dados originais, você deve criar um ponto de acesso do S3 e associá-lo ao bucket do S3 criado na [Etapa 1](#ol-pii-step1). O ponto de acesso deve estar na mesma Região da AWS que os objetos que você deseja transformar.
Mais adiante neste tutorial, você usará esse ponto de acesso como um ponto de acesso de suporte para o ponto de acesso do Object Lambda.
**Como criar um ponto de acesso**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação, escolha **Access Points** (Pontos de acesso).
1. Na página **Access Points** (Pontos de acesso), escolha **Create access point** (Criar ponto de acesso).
1. No campo **Access point name** (Nome do ponto de acesso), insira o nome (por exemplo, **tutorial-pii-access-point**) para o ponto de acesso.
Para obter mais informações sobre nomenclatura de pontos de acesso, consulte [Regras de nomenclatura para pontos de acesso](access-points-restrictions-limitations-naming-rules.md#access-points-names).
1. No campo **Fonte de dados** insira o nome do bucket criado na [Etapa 1](#ol-pii-step1) (por exemplo, **tutorial-bucket**). O S3 anexa o ponto de acesso a este bucket.
(Opcional) Você pode escolher **Browse S3** (Procurar S3) para navegar e pesquisar buckets na sua conta. Se você escolher **Browse S3** (Procurar S3), selecione o bucket desejado e escolha **Choose path** (Escolher caminho) para preencher o campo **Bucket name** (Nome do bucket) com o nome do bucket.
1. Para **Network origin** (Origem de rede), escolha **Internet**.
Para obter mais informações sobre origens de rede para pontos de acesso, consulte [Criar pontos de acesso restritos a uma nuvem privada virtual](access-points-vpc.md).
1. Por padrão, todas as configurações de bloqueio de acesso público são habilitadas para seu ponto de acesso. Recomendamos manter a opção **Block *all* public access** (Bloquear todo o acesso público) ativada. Para obter mais informações, consulte [Gerenciar o acesso público a pontos de acesso para buckets de uso geral](access-points-bpa-settings.md).
1. Para todas as outras configurações de ponto de acesso, mantenha as configurações padrão.
(Opcional) Você pode modificar as configurações do ponto de acesso para dar suporte ao caso de uso. Para este tutorial, recomendamos manter as configurações padrão.
(Opcional) Se você precisar gerenciar o acesso ao seu ponto de acesso, você pode especificar uma política de ponto de acesso. Para obter mais informações, consulte [Exemplos de política para pontos de acesso](access-points-policies.md#access-points-policy-examples).
1. Selecione **Create access point** (Criar ponto de acesso).
## Etapa 4: configurar e implantar uma função Lambda pré-construída
Para editar dados de PII, configure e implante a função `ComprehendPiiRedactionS3ObjectLambda` do AWS Lambda pré-criada para uso com o ponto de acesso do S3 Object Lambda.
**Para configurar e implantar a função Lambda**
1. Faça login no Console de gerenciamento da AWS e visualize a função [https://console.aws.amazon.com/lambda/home#/create/app?applicationId=arn:aws:serverlessrepo:us-east-1:839782855223:applications/ComprehendPiiRedactionS3ObjectLambda](https://console.aws.amazon.com/lambda/home#/create/app?applicationId=arn:aws:serverlessrepo:us-east-1:839782855223:applications/ComprehendPiiRedactionS3ObjectLambda) no AWS Serverless Application Repository.
1. Para **Application settings** (Configurações da aplicação), em **Application name** (Nome da aplicação), mantenha o valor padrão (`ComprehendPiiRedactionS3ObjectLambda`) para este tutorial.
(Opcional) Você pode inserir o nome que deseja dar a esta aplicação. Talvez você queira fazer isso se pretende configurar várias funções Lambda para diferentes necessidades de acesso para o mesmo conjunto de dados compartilhado.
1. Para **MaskCharacter**, mantenha o valor padrão (`*`). O caractere de máscara substitui cada caractere na entidade PII editada.
1. Para **MaskMode**, mantenha o valor padrão (**MASK**). O valor **MaskMode** especifica se a entidade de PII é editada com o caractere `MASK` ou com o valor `PII_ENTITY_TYPE`.
1. Para editar os tipos de dados especificados, para**PiiEntityTypes**, mantenha o valor padrão **ALL**. O valor **PiiEntityTypes** especifica os tipos de entidade de PII a serem considerados para edição.
Para obter mais informações sobre a lista de tipos de entidade PII compatíveis, consulte [Detectar informações de identificação pessoal (PII)](https://docs.aws.amazon.com/comprehend/latest/dg/how-pii.html) no *Guia do desenvolvedor do Amazon Comprehend*.
1. Mantenha as configurações restantes definidas conforme os padrões.
(Opcional) Se quiser definir configurações adicionais para o caso de uso específico, consulte a seção **Readme file** (Arquivo Leiame) no lado esquerdo da página.
1. Marque a caixa de seleção próxima a **I acknowledge that this app creates custom IAM roles** (Reconheço que esta aplicação cria funções personalizadas do IAM).
1. Escolha **Implantar**.
1. Na página da nova aplicação, em **Resources** (Recursos), escolha o **Logical ID** (ID lógico) da função Lambda que você implantou para revisar a função na página da função Lambda.
## Etapa 5: criar um ponto de acesso do S3 Object Lambda
Um ponto de acesso do S3 Object Lambda fornece a flexibilidade de invocar uma função do Lambda diretamente de uma solicitação do S3 GET para que a função possa editar dados PII recuperados de um ponto de acesso do S3. Ao criar e configurar um ponto de acesso do S3 Object Lambda, você deve especificar a função do Lambda de redação para invocar e fornecer o contexto de evento no formato JSON como parâmetros personalizados para o Lambda usar.
O contexto do evento fornece informações sobre a solicitação que está sendo feita no evento passado do S3 Object Lambda para o Lambda. Para obter mais informações sobre todos os campos no contexto do evento, consulte [Formato e uso de contexto de evento](olap-event-context.md).
**Para criar um ponto de acesso do S3 Object Lambda**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Object Lambda access points** (Pontos de acesso do Object Lambda).
1. Na página **Object Lambda Access Points** (Pontos de acesso do Object Lambda), escolha **Create Object Lambda Access Point** (Criar ponto de acesso do Object Lambda).
1. Para **Nome do Ponto de acesso Lambda do objeto**, informe o nome que você deseja usar para o ponto de acesso Lambda do objeto (por exemplo, **tutorial-pii-object-lambda-accesspoint**).
1. Para **Supporting Access Point** (Ponto de acesso de suporte), informe ou procure o ponto de acesso padrão criado na [Etapa 3](#ol-pii-step3) (por exemplo, **tutorial-pii-access-point**) e, em seguida, escolha **Choose supporting Access Point** (Escolher ponto de acesso de suporte).
1. Para recuperar objetos do bucket do S3 para que a função do Lambda processe, selecione **GetObject** em **S3 APIs** (APIs do S3).
1. Para **Invoke Lambda function** (Chamar função Lambda), você pode escolher qualquer uma das duas opções a seguir para este tutorial.
+ Selecione **Escolha entre as funções da sua conta** e escolha a função do Lambda que você criou na [Etapa 4](#ol-pii-step4) (por exemplo, **serverlessrepo-ComprehendPiiRedactionS3ObjectLambda**) da lista suspensa **Função do Lambda**.
+ Escolha **Enter ARN** (Inserir ARN) e depois informe o Nome do recurso da Amazon (ARN) da função Lambda que você criou na [Etapa 4](#ol-pii-step4).
1. Para **Lambda function version** (Versão da função Lambda), escolha **\$1LATEST** (a versão mais recente da função Lambda que você implantou na [Etapa 4](#ol-pii-step4)).
1. (Opcional) Se precisar da função Lambda para reconhecer e processar solicitações GET com cabeçalhos de intervalo e número de peça, selecione **Lambda function supports requests using range** (A função Lambda suporta solicitações usando intervalo) e **Lambda function supports requests using part numbers** (A função Lambda suporta solicitações usando números de parte). Caso contrário, desmarque essas duas caixas de seleção.
Para obter mais informações sobre como usar números de intervalo ou de parte com o S3 Object Lambda, consulte [Trabalhar com cabeçalhos Range e partNumber](range-get-olap.md).
1. (Opcional) Em **Payload - *optional*** (Carga útil - opcional), adicione um texto JSON para fornecer informações adicionais à sua função Lambda.
Uma carga útil é um texto JSON opcional que você pode fornecer à sua função do Lambda como entrada para todas as chamadas provenientes de um ponto de acesso do S3 Object Lambda específico. Para personalizar os comportamentos de vários pontos de acesso Lambda do objeto que chamam a mesma função do Lambda, você pode configurar cargas úteis com diferentes parâmetros, estendendo, assim, a flexibilidade da função do Lambda.
Para obter mais informações sobre carga útil, consulte [Formato e uso de contexto de evento](olap-event-context.md).
1. (Opcional) Em **Métricas de solicitação – *opcional***, escolha **Desabilitar** ou **Habilitar** para adicionar o monitoramento do Amazon S3 ao ponto de acesso do Object Lambda. As métricas de solicitação são cobradas na taxa padrão do Amazon CloudWatch. Para obter mais informações, consulte [Preço do CloudWatch.](https://aws.amazon.com/cloudwatch/pricing/)
1. Em **Object Lambda Access Point policy - *optional*** (Política do ponto de acesso do Object Lambda - opcional), mantenha a configuração padrão.
(Opcional) Você pode definir uma política de recursos. Essa política de recursos concede permissão da API `GetObject` para usar o ponto de acesso do Object Lambda especificado.
1. Mantenha as configurações restantes definidas conforme os padrões e escolha **Create Object Lambda Access Point** (Criar ponto de acesso do Object Lambda).
## Etapa 6: usar o ponto de acesso do S3 Object Lambda para recuperar o arquivo editado
Agora, o S3 Object Lambda está pronto para editar dados de PII do seu arquivo original.
**Para usar o ponto de acesso do S3 Object Lambda para recuperar o arquivo editado**
Quando você solicita para recuperar um arquivo por meio do ponto de acesso do S3 Object Lambda, você faz uma chamada de API `GetObject` para o S3 Object Lambda. O S3 Object Lambda chama a função Lambda para editar seus dados de PII e retorna os dados transformados como a resposta à chamada de API `GetObject` do S3 padrão.
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Object Lambda access points** (Pontos de acesso do Object Lambda).
1. Na página **Pontos de acesso do Object Lambda**, escolha o ponto de acesso do S3 Object Lambda que você criou na [Etapa 5](#ol-pii-step5) (por exemplo, **tutorial-pii-object-lambda-accesspoint**).
1. Na guia **Objetos** do ponto de acesso do S3 Object Lambda, selecione o arquivo que tem o mesmo nome (por exemplo, `tutorial.txt`) daquele que você carregou no bucket do S3 na [Etapa 2](#ol-pii-step2).
Esse arquivo deve conter todos os dados transformados.
1. Para exibir os dados transformados, escolha **Open** (Abrir) ou **Download** (Baixar).
Você deve ser capaz de ver o arquivo editado, conforme mostrado no exemplo a seguir.
```
Hello *********. Your AnyCompany Financial Services,
LLC credit card account ******************* has a minimum payment
of $24.53 that is due by *********. Based on your autopay settings,
we will withdraw your payment on the due date from your
bank account ********** with the routing number *********.
Your latest statement was mailed to **********************************.
After your payment is received, you will receive a confirmation
text message at ************.
If you have questions about your bill, AnyCompany Customer Service
is available by phone at ************ or
email at **********************.
```
## Etapa 7: limpar
Se você editou seus dados por meio do S3 Object Lambda apenas como um exercício de aprendizado, exclua os recursos da AWS que você alocou para que não haja mais encargos.
**Topics**
+ [
### Excluir o ponto de acesso do Object Lambda
](#ol-pii-step8-delete-olap)
+ [
### Exclua o ponto de acesso do S3
](#ol-pii-step8-delete-ap)
+ [
### Excluir a função Lambda
](#ol-pii-step8-delete-lambda-function)
+ [
### Excluir o grupo de logs do CloudWatch
](#ol-pii-step8-delete-cloudwatch)
+ [
### Exclua o arquivo original no bucket de origem do S3
](#ol-pii-step8-delete-file)
+ [
### Exclua o bucket de origem do S3
](#ol-pii-step8-delete-bucket)
+ [
### Exclua a função do IAM para a função Lambda
](#ol-pii-step8-delete-lambda-role)
+ [
### Exclua a política gerenciada pelo cliente para o usuário do IAM
](#ol-pii-step8-delete-function-policy)
+ [
### Excluir o usuário do IAM
](#ol-pii-step8-delete-user)
### Excluir o ponto de acesso do Object Lambda
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Object Lambda access points** (Pontos de acesso do Object Lambda).
1. Na página **Pontos de acesso do Object Lambda**, escolha o botão de opção à esquerda do ponto de acesso do S3 Object Lambda que você criou na [Etapa 5](#ol-pii-step5) (por exemplo, **tutorial-pii-object-lambda-accesspoint**).
1. Escolha **Excluir**.
1. Confirme se deseja excluir o ponto de acesso do Lambda, inserindo o nome no campo de texto exibido e escolha **Excluir**.
### Exclua o ponto de acesso do S3
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação, escolha **Access Points** (Pontos de acesso).
1. Navegue até o ponto de acesso que você criou na [Etapa 3](#ol-pii-step3) (por exemplo, **tutorial-pii-access-point**) e escolha o botão de opção ao lado do nome do ponto de acesso.
1. Escolha **Excluir**.
1. Confirme se deseja excluir o ponto de acesso inserindo o nome no campo de texto exibido e escolha **Delete** (Excluir).
### Excluir a função Lambda
1. No console do AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/), escolha **Functions** (Funções) no painel de navegação à esquerda.
1. Escolha a função que você criou na [Etapa 4](#ol-pii-step4) (por exemplo, **serverlessrepo-ComprehendPiiRedactionS3ObjectLambda**).
1. Escolha **Ações** e, em seguida, escolha **Excluir**.
1. Na caixa de diálogo **Delete function** (Excluir função), escolha **Delete** (Excluir).
### Excluir o grupo de logs do CloudWatch
1. Abra o console do CloudWatch em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação esquerdo, escolha **Log groups** (Grupos de log).
1. Localize o grupo de logs cujo nome termina com a função Lambda que você criou na [Etapa 4](#ol-pii-step4) (por exemplo, **serverlessrepo-ComprehendPiiRedactionS3ObjectLambda**).
1. Escolha **Actions** (Ações) e **Delete log group(s)** (Excluir grupo(s) de log).
1. Na caixa de diálogo **Delete log group(s)** (Excluir grupo(s) de logs), escolha **Delete** (Excluir).
### Exclua o arquivo original no bucket de origem do S3
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Buckets**.
1. Na lista **Bucket name** (Nome do bucket), escolha o nome do bucket para o qual você carregou o arquivo original na [Etapa 2](#ol-pii-step2) (por exemplo, **tutorial-bucket**).
1. Marque a caixa de seleção à esquerda do nome do objeto que você deseja excluir (por exemplo, `tutorial.txt`).
1. Escolha **Excluir**.
1. Na página **Delete objects** (Excluir objetos) na seção **Permanently delete objects?** (Excluir objetos permanentemente?), confirme se deseja excluir este objeto informando **permanently delete** na caixa de texto.
1. Escolha **Delete objects** (Excluir objetos).
### Exclua o bucket de origem do S3
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Buckets**.
1. Na lista de **Buckets**, escolha o botão de opção ao lado do nome do bucket que você criou na [Etapa 1](#ol-pii-step1) (por exemplo, **tutorial-bucket**).
1. Escolha **Excluir**.
1. Na página **Delete bucket** (Excluir bucket), confirme se deseja excluir o bucket inserindo o nome do bucket no campo de texto e escolha **Delete bucket** (Excluir bucket).
### Exclua a função do IAM para a função Lambda
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação esquerdo, escolha **Roles** (Funções) e marque a caixa de seleção ao lado do nome da função que você deseja excluir. O nome da função começa com o nome da função Lambda que você implantou na [Etapa 4](#ol-pii-step4) (por exemplo, **serverlessrepo-ComprehendPiiRedactionS3ObjectLambda**).
1. Escolha **Excluir**.
1. Na caixa de diálogo **Delete** (Excluir), informe o nome da função no campo de entrada de texto para confirmar a exclusão. Em seguida, selecione **Excluir**.
### Exclua a política gerenciada pelo cliente para o usuário do IAM
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação à esquerda, escolha **Políticas**.
1. Na página **Policies** (Políticas), insira o nome da política gerenciada pelo cliente que você criou em [Prerequisites](#ol-pii-prerequisites) (Pré-requisitos) (por exemplo, **tutorial-serverless-application-repository**) na caixa de pesquisa para filtrar a lista de políticas. Selecione o botão de opção ao lado do nome da política que você deseja excluir.
1. Escolha **Ações** e, em seguida, escolha **Excluir**.
1. Confirme se deseja excluir esta política, inserindo seu nome no campo de texto exibido e escolha **Delete** (Excluir).
### Excluir o usuário do IAM
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação esquerdo, escolha **Users** (Usuários) e marque a caixa de seleção ao lado do nome do usuário que você deseja excluir.
1. Na parte superior da página, escolha **Delete** (Excluir).
1. Na caixa de diálogo **Delete *user name*?** (Excluir nome de usuário?), insira o nome de usuário no campo de entrada de texto para confirmar a exclusão do usuário. Escolha **Excluir**.
## Próximas etapas
Depois de concluir este tutorial, você pode explorar ainda mais os seguintes casos de uso relacionados:
+ Você pode criar vários pontos de acesso do S3 Object Lambda e habilitá-los com funções do Lambda pré-criadas que são configuradas de forma diferente para editar tipos específicos de PII, dependendo das necessidades de negócios dos assessores de dados.
Cada tipo de usuário assume um perfil do IAM e só tem acesso a um ponto de acesso do S3 Object Lambda (gerenciado por meio de políticas do IAM). Depois, anexe cada função do Lambda `ComprehendPiiRedactionS3ObjectLambda` configurada para um caso de uso de edição diferente para um ponto de acesso do S3 Object Lambda diferente. Para cada ponto de acesso do S3 Object Lambda, você pode ter um ponto de acesso do S3 de suporte para ler dados de um bucket do S3 que armazena o conjunto de dados compartilhado.
Para obter mais informações sobre como criar uma política de bucket do S3 que conceda aos usuários a leitura do bucket somente por meio dos pontos de acesso do S3, consulte [Configurar políticas do IAM para uso de pontos de acesso](access-points-policies.md).
Para obter mais informações sobre como conceder permissão de usuário para acessar a função do Lambda, o ponto de acesso S3 e o ponto de acesso do S3 Object Lambda, consulte [Configurar políticas do IAM para pontos de acesso do Object Lambda](olap-policies.md).
+ Você pode criar sua própria função Lambda e usar o S3 Object Lambda com sua função Lambda personalizada para atender às suas necessidades de dados específicas.
Por exemplo, para explorar vários valores de dados, você pode usar o S3 Object Lambda e sua própria função Lambda que usa [Recursos do Amazon Comprehend](https://aws.amazon.com/comprehend/features/), como reconhecimento de entidade, reconhecimento de frase-chave, análise de sentimento e classificação de documentos, para processar dados. Você também pode usar o S3 Object Lambda junto com o[Amazon Comprehend Medical](https://aws.amazon.com/comprehend/medical/), um serviço de PNL qualificado para HIPAA, para analisar e extrair dados com reconhecimento de contexto.
Para obter mais informações sobre como transformar dados com o S3 Object Lambda e sua própria função Lambda, consulte [Tutorial: Como transformar dados para sua aplicação com o S3 Object Lambda](tutorial-s3-object-lambda-uppercase.md).
# Depurar e solucionar problemas do S3 Object Lambda
**nota**
Desde 7 de novembro de 2025, o S3 Object Lambda está disponível somente para clientes existentes que estão usando o serviço no momento, bem como para parceiros selecionados da Rede de Parceiros da AWS (APN). Para recursos semelhantes ao S3 Object Lambda, saiba mais aqui: [Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html).
As solicitações para pontos de acesso do Amazon S3 Object Lambda podem resultar em novas respostas de erro quando algo der errado com a invocação ou execução da função do Lambda. Esses erros seguem o mesmo formato que os erros padrão do Amazon S3. Para obter informações sobre erros do S3 Object Lambda, consulte [Lista de códigos de erro do S3 Object Lambda](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#S3ObjectLambdaErrorCodeList) na *Referência da API do Amazon Simple Storage Service*.
Para obter mais informações sobre a depuração geral da função do Lambda, consulte [Monitoramento e solução de problemas de aplicações do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html ) no *Guia do desenvolvedor do AWS Lambda*.
Para obter informações sobre erros padrão do Amazon S3, consulte [Respostas de erro](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html) na *Referência da API do Amazon Simple Storage Service*.
Você pode habilitar métricas de solicitação no Amazon CloudWatch para os pontos de acesso do Object Lambda. Essas métricas ajudam você a monitorar a performance operacional do seu ponto de acesso. Você pode habilitar métricas de solicitação durante ou após a criação de um ponto de acesso do Object Lambda. Para obter mais informações, consulte [Métricas de solicitação do S3 Object Lambda no CloudWatch](metrics-dimensions.md#olap-cloudwatch-metrics).
Para obter registros em log mais granulares sobre solicitações feitas aos seus pontos de acesso do Object Lambda, é possível ativar eventos de dados do AWS CloudTrail. Para obter mais informações, consulte [Registro eventos de dados em logs para trilhas](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html) no *Guia do usuário do AWS CloudTrail*.
Para tutoriais do S3 Object Lambda, consulte o seguinte:
+ [Tutorial: Como transformar dados para sua aplicação com o S3 Object Lambda](tutorial-s3-object-lambda-uppercase.md)
+ [Tutorial: Detectar e editar dados PII com o S3 Object Lambda e o Amazon Comprehend](tutorial-s3-object-lambda-redact-pii.md)
+ [Tutorial: Using S3 Object Lambda to dynamically watermark images as they are retrieved (Tutorial: Como usar o S3 Object Lambda para colocar marca d’água em imagens de maneira dinâmica à medida que são recuperadas](https://aws.amazon.com/getting-started/hands-on/amazon-s3-object-lambda-to-dynamically-watermark-images/?ref=docs_gateway/amazons3/transforming-objects.html)
Para obter mais informações sobre pontos de acesso padrão, consulte [Gerenciar o acesso a conjuntos de dados compartilhados com pontos de acesso](access-points.md).
Para obter informações sobre como trabalhar com buckets, consulte [Visão geral dos buckets de uso geral](UsingBucket.md). Para obter mais informações sobre como trabalhar com objetos, consulte [Visão geral de objetos Amazon S3](UsingObjects.md).