As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Introdução ao testes com o comando sam local Use o AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam local` para testar seus aplicativos sem servidor localmente. Para obter uma introdução ao AWS SAMCLI, consulte[O que é o AWS SAMCLI?](what-is-sam-overview.md#what-is-sam-cli). ## Pré-requisitos Para usar o `sam local`, instale o AWS SAM CLI fazendo o seguinte: + [AWS SAM pré-requisitos](prerequisites.md). + [Instale o AWS SAM CLI](install-sam-cli.md). Antes de usar `sam local`, recomendamos uma compreensão básica do seguinte: + [Configurando o AWS SAM CLI](using-sam-cli-configure.md). + [Crie seu aplicativo em AWS SAM](using-sam-cli-init.md). + [Introdução à construção com AWS SAM](using-sam-cli-build.md). + [Introdução à implantação com AWS SAM](using-sam-cli-deploy.md). ## Usar o comando sam local Use o comando `sam local` com qualquer um de seus subcomandos para realizar diferentes tipos de testes locais para seu aplicativo. ``` $ sam local ``` Para obter mais informações sobre cada subcomando, veja o seguinte: + **[Introdução a sam local generate-event](using-sam-cli-local-generate-event.md)**— Gere AWS service (Serviço da AWS) eventos para testes locais. + **[Introdução a sam local invoke](using-sam-cli-local-invoke.md)** – Inicie uma invocação única de uma função AWS Lambda localmente. + **[Introdução a sam local start-api](using-sam-cli-local-start-api.md)** – Execute suas funções do Lambda usando um servidor HTTP local. + **[Introdução a sam local start-lambda](using-sam-cli-local-start-lambda.md)**— Execute suas funções do Lambda usando um servidor HTTP local para uso com o AWS CLI ou. SDKs # Introdução aos testes com sam local generate-event Use o AWS Serverless Application Model `sam local generate-event` subcomando Command Line Interface (AWS SAMCLI) para gerar amostras de carga útil de eventos para suporte. Serviços da AWS Em seguida, você pode modificar e passar esses eventos para os recursos locais para testes. + Para obter uma introdução ao AWS SAMCLI, consulte [O que é o AWS SAMCLI?](what-is-sam-overview.md#what-is-sam-cli) + Para obter uma lista de opções de comando `sam local generate-event`, consulte [sam local generate-event](sam-cli-command-reference-sam-local-generate-event.md). Um *evento* é um objeto JSON que é gerado quando um AWS service (Serviço da AWS) executa uma ação ou tarefa. Esses eventos contêm informações específicas, como os dados que foram processados ou a data e hora do evento. A maioria Serviços da AWS gera eventos e os eventos de cada serviço são formatados exclusivamente para seu serviço. Os eventos gerados por um serviço são passados para outros serviços como uma *fonte de eventos*. Por exemplo, um item colocado em um bucket do Amazon Simple Storage Service (Amazon S3) pode gerar um evento. Esse evento pode então ser usado como fonte de eventos para que uma AWS Lambda função processe ainda mais os dados. Os eventos que você gera com `sam local generate-event` são formatados na mesma estrutura dos eventos reais criados pelo AWS serviço. Você pode modificar o conteúdo desses eventos e usá-los para testar recursos em seu aplicativo. ## Pré-requisitos Para usar o `sam local generate-event`, instale o AWS SAM CLI fazendo o seguinte: + [AWS SAM pré-requisitos](prerequisites.md). + [Instale o AWS SAM CLI](install-sam-cli.md). Antes de usar `sam local generate-event`, recomendamos uma compreensão básica do seguinte: + [Configurando o AWS SAM CLI](using-sam-cli-configure.md). + [Crie seu aplicativo em AWS SAM](using-sam-cli-init.md). + [Introdução à construção com AWS SAM](using-sam-cli-build.md). + [Introdução à implantação com AWS SAM](using-sam-cli-deploy.md). ## Gere eventos de exemplo Use o AWS SAMCLI `sam local generate-event` subcomando para gerar eventos para suporte Serviços da AWS. **Para ver uma lista de opções suportadas Serviços da AWS** 1. Execute o seguinte: ``` $ sam local generate-event ``` 1. A lista de compatíveis Serviços da AWS será exibida. Este é um exemplo: ``` $ sam local generate-event ... Commands: alb alexa-skills-kit alexa-smart-home apigateway appsync batch cloudformation ... ``` **Para gerar um evento local** 1. Execute `sam local generate-event` e forneça o nome do serviço suportado. Isso exibirá uma lista de tipos de eventos que você pode gerar. Este é um exemplo: ``` $ sam local generate-event s3 Usage: sam local generate-event s3 [OPTIONS] COMMAND [ARGS]... Options: -h, --help Show this message and exit. Commands: batch-invocation Generates an Amazon S3 Batch Operations Invocation Event delete Generates an Amazon S3 Delete Event put Generates an Amazon S3 Put Event ``` 1. Para gerar o evento de amostra, execute `sam local generate-event`, fornecendo o serviço e o tipo de evento. ``` $ sam local generate-event ``` Este é um exemplo: ``` $ sam local generate-event s3 put { "Records": [ { "eventVersion": "2.0", "eventSource": "aws:s3", "awsRegion": "us-east-1", "eventTime": "1970-01-01T00:00:00.000Z", "eventName": "ObjectCreated:Put", "userIdentity": { "principalId": "EXAMPLE" }, "requestParameters": { "sourceIPAddress": "127.0.0.1" }, "responseElements": { "x-amz-request-id": "EXAMPLE123456789", "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH" }, "s3": { "s3SchemaVersion": "1.0", "configurationId": "testConfigRule", "bucket": { "name": "sam-s3-demo-bucket", "ownerIdentity": { "principalId": "EXAMPLE" }, "arn": "arn:aws:s3:::sam-s3-demo-bucket" }, "object": { "key": "test/key", "size": 1024, "eTag": "0123456789abcdef0123456789abcdef", "sequencer": "0A1B2C3D4E5F678901" } } } ] } ``` Esses exemplos de eventos contêm valores de espaço reservado. Você pode modificar esses valores para referenciar recursos reais em seu aplicativo ou valores para ajudar nos testes locais. **Para modificar um evento de amostra** 1. Você pode modificar eventos de amostra no prompt de comando. Para ver suas opções, execute o seguinte: ``` $ sam local generate-event --help ``` Este é um exemplo: ``` $ sam local generate-event s3 put --help Usage: sam local generate-event s3 put [OPTIONS] Options: --region TEXT Specify the region name you'd like, otherwise the default = us-east-1 --partition TEXT Specify the partition name you'd like, otherwise the default = aws --bucket TEXT Specify the bucket name you'd like, otherwise the default = example-bucket --key TEXT Specify the key name you'd like, otherwise the default = test/key --debug Turn on debug logging to print debug message generated by AWS SAM CLI and display timestamps. --config-file TEXT Configuration file containing default parameter values. [default: samconfig.toml] --config-env TEXT Environment name specifying default parameter values in the configuration file. [default: default] -h, --help Show this message and exit. ``` 1. Use qualquer uma dessas opções no prompt de comando para modificar a carga útil do evento de amostra. Este é um exemplo: ``` $ sam local generate-event s3 put--bucket sam-s3-demo-bucket { "Records": [ { "eventVersion": "2.0", "eventSource": "aws:s3", "awsRegion": "us-east-1", "eventTime": "1970-01-01T00:00:00.000Z", "eventName": "ObjectCreated:Put", "userIdentity": { "principalId": "EXAMPLE" }, "requestParameters": { "sourceIPAddress": "127.0.0.1" }, "responseElements": { "x-amz-request-id": "EXAMPLE123456789", "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH" }, "s3": { "s3SchemaVersion": "1.0", "configurationId": "testConfigRule", "bucket": { "name": "sam-s3-demo-bucket", "ownerIdentity": { "principalId": "EXAMPLE" }, "arn": "arn:aws:s3:::sam-s3-demo-bucket" }, "object": { "key": "test/key", "size": 1024, "eTag": "0123456789abcdef0123456789abcdef", "sequencer": "0A1B2C3D4E5F678901" } } } ] } ``` ## Use eventos gerados para testes locais Salve seus eventos gerados localmente e use outros subcomandos `sam local` para testar. **Para salvar seus eventos gerados localmente** + Execute o seguinte: ``` $ sam local generate-event > ``` Veja a seguir um exemplo de um evento sendo salvo como um `s3.json` arquivo na `events` pasta do nosso projeto. ``` sam-app$ sam local generate-event s3 put --bucket amzn-s3-demo-bucket > events/s3.json ``` **Para usar um evento gerado para testes locais** + Passe o evento com outros subcomandos `sam local` usando a opção `--event`. Veja a seguir um exemplo de uso do evento `s3.json` para invocar nossa função do Lambda localmente: ``` sam-app$ sam local invoke --event events/s3.json S3JsonLoggerFunction Invoking src/handlers/s3-json-logger.s3JsonLoggerHandler (nodejs18.x) Local image is up-to-date Using local image: public.ecr.aws/lambda/nodejs:18-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/S3JsonLoggerFunction as /var/task:ro,delegated, inside runtime container START RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 Version: $LATEST END RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 REPORT RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 Init Duration: 1.23 ms Duration: 9371.93 ms Billed Duration: 9372 ms Memory Size: 128 MB Max Memory Used: 128 MB ``` ## Saiba mais Para obter uma lista de todas as opções `sam local generate-event`, consulte [sam local generate-event](sam-cli-command-reference-sam-local-generate-event.md). Para uma demonstração do uso `sam local`, consulte [AWS SAM para desenvolvimento local. Testando Nuvem AWS recursos de ambientes de desenvolvimento local](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24) na *série Serverless Land Sessions with SAM on*. YouTube # Introdução aos testes com sam local invoke Use o AWS Serverless Application Model `sam local invoke` subcomando Command Line Interface (AWS SAMCLI) para iniciar localmente uma invocação única de uma função. AWS Lambda + Para obter uma introdução ao AWS SAMCLI, consulte [O que é o AWS SAMCLI?](what-is-sam-overview.md#what-is-sam-cli) + Para obter uma lista de opções de comando `sam local invoke`, consulte [sam local invoke](sam-cli-command-reference-sam-local-invoke.md). + Para obter um exemplo de uso do `sam local invoke` durante um fluxo de trabalho de desenvolvimento típico, consulte [Etapa 7: (opcional) Teste seu aplicativo localmente](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-test). **nota** Não é recomendável usar os recursos de invocação local do SAM CLI em código não confiável. Para ter um isolamento completo do seu ambiente local, execute o código diretamente no serviço Lambda. **nota** `sam local invoke`suporta funções duráveis com recursos automáticos de verificação e repetição. Ao invocar funções duráveis localmente, o estado de execução é gerenciado automaticamente. ## Pré-requisitos Para usar o `sam local invoke`, instale o AWS SAM CLI fazendo o seguinte: + [AWS SAM pré-requisitos](prerequisites.md). + [Instale o AWS SAM CLI](install-sam-cli.md). Antes de usar `sam local invoke`, recomendamos uma compreensão básica do seguinte: + [Configurando o AWS SAM CLI](using-sam-cli-configure.md). + [Crie seu aplicativo em AWS SAM](using-sam-cli-init.md). + [Introdução à construção com AWS SAM](using-sam-cli-build.md). + [Introdução à implantação com AWS SAM](using-sam-cli-deploy.md). ## Invocar uma função do Lambda localmente Quando você executa `sam local invoke`, AWS SAMCLI pressupõe que seu diretório de trabalho atual seja o diretório raiz do seu projeto. O AWS SAM CLI, primeiro procurará um arquivo `template.[yaml|yml]` dentro de uma subpasta `.aws-sam`. Se não for encontrado, o AWS SAMCLI procurará um arquivo `template.[yaml|yml]` em seu diretório de trabalho atual. **Invocar uma função do Lambda localmente** 1. No diretório raiz do seu projeto, execute o seguinte: ``` $ sam local invoke ``` 1. Se seu aplicativo contiver mais de uma função, forneça o ID lógico da função. Este é um exemplo: ``` $ sam local invoke HelloWorldFunction ``` 1. O AWS SAMCLI constrói sua função em um contêiner local Docker. Em seguida, ele invoca sua função e gera a resposta da sua função. Este é um exemplo: ``` $ sam local invoke Invoking app.lambda_handler (python3.9) Local image is out of date and will be updated to the latest runtime. To skip this, pass in the parameter --skip-pull-image Building image.................................................................................................................... Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df Version: $LATEST END RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df REPORT RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df Init Duration: 1.09 ms Duration: 608.42 ms Billed Duration: 609 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode": 200, "body": "{\"message\": \"hello world\"}"}% ``` ### Gerenciar logs do Ao usar `sam local invoke`, a saída de tempo de execução da função do Lambda (por exemplo, registros) é enviada para `stderr` e o resultado da função do Lambda é enviado para `stdout`. Veja a seguir um exemplo de uma função do Lambda básica: ``` def handler(event, context): print("some log") # this goes to stderr return "hello world" # this goes to stdout ``` Você pode salvar essas saídas padrão. Este é um exemplo: ``` $ sam local invoke 1> stdout.log ... $ cat stdout.log "hello world" $ sam local invoke 2> stderr.log ... $ cat stderr.log Invoking app.lambda_handler (python3.9) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 Version: $LATEST some log END RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 REPORT RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 Init Duration: 0.91 ms Duration: 589.19 ms Billed Duration: 590 ms Memory Size: 128 MB Max Memory Used: 128 MB ``` Você pode usar essas saídas padrão para automatizar ainda mais seus processos de desenvolvimento local. ## Opções ### Passe eventos personalizados para invocar a função do Lambda Para passar um evento para a função do Lambda, use a opção `--event`. Este é um exemplo: ``` $ sam local invoke --event events/s3.json S3JsonLoggerFunction ``` Você pode criar eventos com o subcomando `sam local generate-event`. Para saber mais, consulte [Introdução aos testes com sam local generate-event](using-sam-cli-local-generate-event.md). ### Passe variáveis de ambiente ao invocar sua função do Lambda Se sua função do Lambda usa variáveis de ambiente, você pode passá-las durante o teste local com a opção `--env-vars`. Essa é uma ótima maneira de testar uma função do Lambda localmente com serviços da aplicação que já estão implantados na nuvem. Este é um exemplo: ``` $ sam local invoke --env-vars locals.json ``` ### Especificar um modelo ou função Para especificar um modelo para o AWS SAMCLI para referência, use a opção `--template`. Eles AWS SAMCLI carregarão apenas esse AWS SAM modelo e os recursos para os quais ele aponta. Para invocar uma função de um aplicativo ou pilha aninhada, forneça o ID lógico do aplicativo ou da pilha junto com o ID lógico da função. Este é um exemplo: ``` $ sam local invoke StackLogicalId/FunctionLogicalId ``` ### Testar uma função do Lambda no seu projeto Terraform Use a opção `--hook-name` de testar localmente as funções do Lambda em seus projetos Terraform. Para saber mais, consulte [Usando o AWS SAMCLI with Terraform para depuração e teste locais](using-samcli-terraform.md). Este é um exemplo: ``` $ sam local invoke --hook-name terraform --beta-features ``` ## Práticas recomendadas Se seu aplicativo tiver um diretório `.aws-sam` executando `sam build`, certifique-se de executar o `sam build` sempre que atualizar o código da função. Em seguida, execute o `sam local invoke` para testar localmente seu código de função atualizado. O teste local é uma ótima solução para desenvolvimento e teste rápidos antes da implantação na nuvem. No entanto, os testes locais não validam tudo, como permissões entre seus recursos na nuvem. Tanto quanto possível, teste seus aplicativos na nuvem. Recomendamos [usar o `sam sync`](using-sam-cli-sync.md) para acelerar seus fluxos de trabalho de testes na nuvem. ## Exemplos ### Gere um evento de amostra do Amazon API Gateway e use-o para invocar uma função do Lambda localmente Primeiro, geramos uma carga útil de evento de API HTTP do API Gateway e a salvamos em nossa pasta `events`. ``` $ sam local generate-event apigateway http-api-proxy > events/apigateway_event.json ``` Em seguida, modificamos nossa função do Lambda para retornar um valor de parâmetro do evento. ``` def lambda_handler(event, context): print("HelloWorldFunction invoked") return { "statusCode": 200, "body": json.dumps({ "message": event['queryStringParameters']['parameter2'], }), } ``` Em seguida, invocamos localmente nossa função do Lambda e fornecemos nosso evento personalizado. ``` $ sam local invoke --event events/apigateway_event.json Invoking app.lambda_handler (python3.9) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/...sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Version: $LATEST some log END RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 REPORT RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Init Duration: 1.63 ms Duration: 564.07 ms Billed Duration: 565 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode": 200, "body": "{\"message\": \"value\"}"}% ``` ### Passe variáveis de ambiente ao invocar uma função do Lambda localmente Esse aplicativo tem uma função do Lambda que usa uma variável de ambiente para o nome de uma tabela do Amazon DynamoDB. Veja a seguir um exemplo da função definida no AWS SAM modelo: ``` AWSTemplateFormatVersion: 2010-09-09 Transform: AWS::Serverless-2016-10-31 ... Resources: getAllItemsFunction: Type: AWS::Serverless::Function Properties: Handler: src/get-all-items.getAllItemsHandler Description: get all items Policies: - DynamoDBReadPolicy: TableName: !Ref SampleTable Environment: Variables: SAMPLE_TABLE: !Ref SampleTable ... ``` Queremos testar localmente nossa função do Lambda enquanto ela interage com nossa tabela do DynamoDB na nuvem. Para fazer isso, criamos nosso arquivo de variáveis de ambiente e o salvamos no diretório raiz do nosso projeto como `locals.json`. O valor fornecido aqui `SAMPLE_TABLE` faz referência à nossa tabela do DynamoDB na nuvem. ``` { "getAllItemsFunction": { "SAMPLE_TABLE": "dev-demo-SampleTable-1U991234LD5UM98" } } ``` Em seguida, executamos `sam local invoke` e passamos nossas variáveis de ambiente com a opção `--env-vars`. ``` $ sam local invoke getAllItemsFunction --env-vars locals.json Mounting /Users/...sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Version: $LATEST some log END RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 REPORT RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Init Duration: 1.63 ms Duration: 564.07 ms Billed Duration: 565 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode":200,"body":"{}"} ``` ## Saiba mais Para obter uma lista de todas as opções `sam local invoke`, consulte [sam local invoke](sam-cli-command-reference-sam-local-invoke.md). Para uma demonstração do uso `sam local`, consulte [AWS SAM para desenvolvimento local. Testando Nuvem AWS recursos de ambientes de desenvolvimento local](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24) na *série Serverless Land Sessions with SAM on*. YouTube # Introdução aos testes com sam local start-api Use o AWS Serverless Application Model `sam local start-api` subcomando Command Line Interface (AWS SAMCLI) para executar suas AWS Lambda funções localmente e testar por meio de um host de servidor HTTP local. Esse tipo de teste é útil para funções do Lambda invocadas por um endpoint do Amazon API Gateway. + Para uma introdução ao AWS SAMCLI, consulte [O que é o AWS SAMCLI?](what-is-sam-overview.md#what-is-sam-cli) + Para obter uma lista de opções de comando `sam local start-api`, consulte [sam local start-api](sam-cli-command-reference-sam-local-start-api.md). + Para obter um exemplo de uso do `sam local start-api` durante um fluxo de trabalho de desenvolvimento típico, consulte [Etapa 7: (opcional) Teste seu aplicativo localmente](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-test). **nota** `sam local start-api`suporta funções duráveis com recursos automáticos de verificação e repetição. As funções duráveis funcionam perfeitamente com o endpoint local do API Gateway. ## Pré-requisitos Para usar o `sam local start-api`, instale o AWS SAM CLI fazendo o seguinte: + [AWS SAM pré-requisitos](prerequisites.md). + [Instale o AWS SAM CLI](install-sam-cli.md). Antes de usar `sam local start-api`, recomendamos uma compreensão básica do seguinte: + [Configurando o AWS SAM CLI](using-sam-cli-configure.md). + [Crie seu aplicativo em AWS SAM](using-sam-cli-init.md). + [Introdução à construção com AWS SAM](using-sam-cli-build.md). + [Introdução à implantação com AWS SAM](using-sam-cli-deploy.md). ## Usando SAM API de inicialização local Quando você executa `sam local start-api`, AWS SAMCLI pressupõe que seu diretório de trabalho atual seja o diretório raiz do seu projeto. O AWS SAM CLI, primeiro procurará um arquivo `template.[yaml|yml]` dentro de uma subpasta `.aws-sam`. Se não for encontrado, o AWS SAMCLI procurará um arquivo `template.[yaml|yml]` em seu diretório de trabalho atual. **Para iniciar um servidor HTTP local** 1. No diretório raiz do seu projeto, execute o seguinte: ``` $ sam local start-api ``` 1. O AWS SAMCLI cria suas funções do Lambda em um contêiner local Docker. Em seguida, ele envia o endereço local para o endpoint do servidor HTTP. Este é um exemplo: ``` $ sam local start-api Initializing the lambda functions containers. Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container Containers Initialization is done. Mounting HelloWorldFunction at http://127.0.0.1:3000/hello [GET] You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template 2023-04-12 14:41:05 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3000 ``` 1. Você pode invocar sua função do Lambda por meio do navegador ou do prompt de comando. Este é um exemplo: ``` sam-app$ curl http://127.0.0.1:3000/hello {"message": "Hello world!"}% ``` 1. Ao fazer alterações no código da função do Lambda, considere o seguinte para atualizar seu servidor HTTP local: + Se seu aplicativo não tiver um diretório `.aws-sam` e sua função usar uma linguagem interpretada, os AWS SAMCLI atualizarão automaticamente sua função criando um novo contêiner e hospedando-o. + Se seu aplicativo tiver um diretório `.aws-sam`, você precisará executar `sam build` para atualizar sua função. Em seguida, execute `sam local start-api` novamente para hospedar a função. + Se sua função usa uma linguagem compilada ou se seu projeto requer suporte a pacotes complexos, execute sua própria solução de compilação para atualizar sua função. Em seguida, execute `sam local start-api` novamente para hospedar a função. ### Funções Lambda que usam autorizadores Lambda **nota** Esse atributo é novo na versão 1.80.0 do AWS SAM CLI. Para atualizar, consulte [Atualizar o AWS SAM CLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade). Para funções Lambda que usam autorizadores Lambda, os AWS SAMCLI invocarão automaticamente seu autorizador Lambda antes de invocar seu endpoint de função do Lambda. Veja a seguir um exemplo de como iniciar um servidor HTTP local para uma função que usa um autorizador Lambda: ``` $ sam local start-api 2023-04-17 15:02:13 Attaching import module proxy for analyzing dynamic imports AWS SAM CLI does not guarantee 100% fidelity between authorizers locally and authorizers deployed on AWS. Any application critical behavior should be validated thoroughly before deploying to production. Testing application behaviour against authorizers deployed on AWS can be done using the sam sync command. Mounting HelloWorldFunction at http://127.0.0.1:3000/authorized-request [GET] You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template 2023-04-17 15:02:13 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3000 2023-04-17 15:02:13 Press CTRL+C to quit ``` Quando você invoca seu endpoint da função do Lambda por meio do servidor HTTP local, o AWS SAMCLI invoca primeiro seu autorizador Lambda. Se a autorização for bem-sucedida, AWS SAM e CLI invocarão seu endpoint da função do Lambda. Este é um exemplo: ``` $ curl http://127.0.0.1:3000/authorized-request --header "header:my_token" {"message": "from authorizer"}% Invoking app.authorizer_handler (python3.8) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.8-rapid-x86_64. Mounting /Users/.../sam-app/... as /var/task:ro,delegated, inside runtime container START RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 Version: $LATEST END RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 REPORT RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 Init Duration: 1.08 ms Duration: 628.26 msBilled Duration: 629 ms Memory Size: 128 MB Max Memory Used: 128 MB Invoking app.request_handler (python3.8) Using local image: public.ecr.aws/lambda/python:3.8-rapid-x86_64. Mounting /Users/.../sam-app/... as /var/task:ro,delegated, inside runtime container START RequestId: fdc12255-79a3-4365-97e9-9459d06446ff Version: $LATEST END RequestId: fdc12255-79a3-4365-97e9-9459d06446ff REPORT RequestId: fdc12255-79a3-4365-97e9-9459d06446ff Init Duration: 0.95 ms Duration: 659.13 msBilled Duration: 660 ms Memory Size: 128 MB Max Memory Used: 128 MB No Content-Type given. Defaulting to 'application/json'. 2023-04-17 15:03:03 127.0.0.1 - - [17/Apr/2023 15:03:03] "GET /authorized-request HTTP/1.1" 200 - ``` ## Opções ### Reutilize continuamente os contêineres para acelerar as invocações de funções locais Por padrão, o AWS SAMCLI cria um novo contêiner toda vez que sua função é invocada por meio do servidor HTTP local. Use a opção `--warm-containers` de reutilizar automaticamente seu contêiner para invocações de funções. Isso acelera o tempo necessário para AWS SAMCLI preparar sua função do Lambda para invocação local. Você pode personalizar ainda mais essa opção fornecendo o argumento `eager` ou `lazy`. + `eager` – Os contêineres para todas as funções são carregados na inicialização e persistem entre as invocações. + `lazy` – Os contêineres são carregados somente quando cada função é invocada pela primeira vez. Eles então persistem para invocações adicionais. Este é um exemplo: ``` $ sam local start-api --warm-containers eager ``` Ao usar `--warm-containers` e modificar o código da função do Lambda: + Se seu aplicativo tiver um diretório `.aws-sam`, execute `sam build` para atualizar o código da função nos artefatos de construção do seu aplicativo. + Quando uma alteração de código é detectada, o AWS SAMCLI desliga automaticamente o contêiner da função do Lambda. + Quando você invoca a função novamente, o AWS SAMCLI cria automaticamente um novo contêiner. ### Especifique uma imagem de contêiner para usar em suas funções do Lambda Por padrão, o AWS SAMCLI usa imagens de base do Lambda do Amazon Elastic Container Registry (Amazon ECR) para invocar suas funções no local. Use a opção `--invoke-image` para referenciar uma imagem de contêiner personalizada. Este é um exemplo: ``` $ sam local start-api --invoke-image public.ecr.aws/sam/emu-python3.8 ``` Você pode especificar a função a ser usada com a imagem personalizada do contêiner. Este é um exemplo: ``` $ sam local start-api --invoke-image Function1=amazon/aws/sam-cli-emulation-image-python3.8 ``` ### Especifique um modelo para testar localmente Para especificar um modelo para o AWS SAMCLI para referência, use a opção `--template`. Eles AWS SAMCLI carregarão apenas esse AWS SAM modelo e os recursos para os quais ele aponta. Este é um exemplo: ``` $ sam local start-api --template myTemplate.yaml ``` ### Especifique o ambiente de desenvolvimento do host da sua função do Lambda Por padrão, o subcomando `sam local start-api` cria um servidor HTTP usando `localhost` com endereço IP `127.0.0.1`. Você pode personalizar esses valores se o ambiente de desenvolvimento local estiver isolado da máquina local. Use a opção `--container-host` para especificar um host. Este é um exemplo: ``` $ sam local start-api --container-host host.docker.internal ``` Use a opção `--container-host-interface` para especificar o endereço IP da rede host à qual as portas do contêiner devem se vincular. Este é um exemplo: ``` $ sam local start-api --container-host-interface 0.0.0.0 ``` ## Práticas recomendadas Se seu aplicativo tiver um diretório `.aws-sam` executando `sam build`, certifique-se de executar o `sam build` sempre que atualizar o código da função. Em seguida, execute o `sam local start-api` para testar localmente seu código de função atualizado. O teste local é uma ótima solução para desenvolvimento e teste rápidos antes da implantação na nuvem. No entanto, os testes locais não validam tudo, como permissões entre seus recursos na nuvem. Tanto quanto possível, teste seus aplicativos na nuvem. Recomendamos [usar o `sam sync`](using-sam-cli-sync.md) para acelerar seus fluxos de trabalho de testes na nuvem. ## Saiba mais Para obter uma lista de todas as opções `sam local start-api`, consulte [sam local start-api](sam-cli-command-reference-sam-local-start-api.md). # Introdução aos testes com sam local start-lambda Use o AWS SAMCLI subcomando `sam local start-lambda` para invocar sua função Lambda por meio do e. AWS CLI SDKs Esse comando inicia um endpoint local que emula o Lambda. + Para obter uma introdução ao AWS SAMCLI, consulte [O que é o AWS SAMCLI?](what-is-sam-overview.md#what-is-sam-cli) + Para obter uma lista de opções de comando `sam local start-lambda`, consulte [sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md). **nota** `sam local start-lambda`suporta funções duráveis com recursos automáticos de verificação e repetição. As funções duráveis funcionam perfeitamente com o endpoint Lambda local. ## Pré-requisitos Para usar o `sam local start-lambda`, instale o AWS SAM CLI fazendo o seguinte: + [AWS SAM pré-requisitos](prerequisites.md). + [Instale o AWS SAM CLI](install-sam-cli.md). Antes de usar `sam local start-lambda`, recomendamos uma compreensão básica do seguinte: + [Configurando o AWS SAM CLI](using-sam-cli-configure.md). + [Crie seu aplicativo em AWS SAM](using-sam-cli-init.md). + [Introdução à construção com AWS SAM](using-sam-cli-build.md). + [Introdução à implantação com AWS SAM](using-sam-cli-deploy.md). ## Usando o Local do SAM start-lambda Quando você executa `sam local start-lambda`, AWS SAMCLI pressupõe que seu diretório de trabalho atual seja o diretório raiz do seu projeto. O AWS SAM CLI, primeiro procurará um arquivo `template.[yaml|yml]` dentro de uma subpasta `.aws-sam`. Se não for encontrado, o AWS SAMCLI procurará um `template.[yaml|yml]` arquivo em seu diretório de trabalho atual. **Para usar o Local do SAM start-lambda** 1. No diretório raiz do seu projeto, execute o seguinte: ``` $ sam local start-lambda ``` 1. O AWS SAMCLI cria suas funções do Lambda em um contêiner Docker local. Em seguida, ele envia o endereço local para o endpoint do servidor HTTP. Este é um exemplo: ``` $ sam local start-lambda Initializing the lambda functions containers. Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/hello_world as /var/task:ro,delegated, inside runtime container Containers Initialization is done. Starting the Local Lambda Service. You can now invoke your Lambda Functions defined in your template through the endpoint. 2023-04-13 07:25:43 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3001 2023-04-13 07:25:43 Press CTRL+C to quit ``` 1. Use o AWS CLI ou SDKs para invocar sua função Lambda localmente. Veja a seguir um exemplo de como usar a AWS CLI: ``` $ aws lambda invoke --function-name "HelloWorldFunction" --endpoint-url "http://127.0.0.1:3001" --no-verify-ssl out.txt StatusCode: 200 (END) ``` Veja a seguir um exemplo usando o AWS SDK forPython: ``` import boto3 from botocore.config import Config from botocore import UNSIGNED lambda_client = boto3.client('lambda', endpoint_url="http://127.0.0.1:3001", use_ssl=False, verify=False, config=Config(signature_version=UNSIGNED, read_timeout=1, retries={'max_attempts': 0} ) ) lambda_client.invoke(FunctionName="HelloWorldFunction") ``` ## Opções ### Especificar um modelo Para especificar um modelo para o AWS SAMCLI para referência, use a opção `--template`. Eles AWS SAMCLI carregarão apenas esse AWS SAM modelo e os recursos para os quais ele aponta. Este é um exemplo: ``` $ sam local start-lambda --template myTemplate.yaml ``` Para obter mais informações sobre AWS SAM modelos, consulte[AWS SAM anatomia do modelo](sam-specification-template-anatomy.md). ## Práticas recomendadas Se seu aplicativo tiver um diretório `.aws-sam` executando `sam build`, certifique-se de executar o `sam build` sempre que atualizar o código da função. Em seguida, execute o `sam local start-lambda` para testar localmente seu código de função atualizado. O teste local é uma ótima solução para desenvolvimento e teste rápidos antes da implantação na nuvem. No entanto, os testes locais não validam tudo, como permissões entre seus recursos na nuvem. Tanto quanto possível, teste seus aplicativos na nuvem. Recomendamos [usar o `sam sync`](using-sam-cli-sync.md) para acelerar seus fluxos de trabalho de testes na nuvem. ## Saiba mais Para obter uma lista de todas as opções `sam local start-lambda`, consulte [sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md).