First write!
"); responseStream.write("${loremIpsum1}
`); await new Promise(r => setTimeout(r, 1000)); responseStream.write("DONE!
"); responseStream.write(""); responseStream.end(); } ); ``` Este é um exemplo de nosso arquivo `template.yaml`. O streaming de resposta para nossa função do Lambda é configurado usando a propriedade `FunctionUrlConfig`. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: > Sample SAM Template for lambda-streaming-nodejs-app Resources: StreamingFunction: Type: AWS::Serverless::Function Properties: CodeUri: src/ Handler: index.handler Runtime: nodejs18.x Architectures: - x86_64 Timeout: 10 FunctionUrlConfig: AuthType: AWS_IAM InvokeMode: RESPONSE_STREAM Outputs: StreamingFunction: Description: "Streaming Lambda Function ARN" Value: !GetAtt StreamingFunction.Arn StreamingFunctionURL: Description: "Streaming Lambda Function URL" Value: !GetAtt StreamingFunctionUrl.FunctionUrl ``` Normalmente, você pode usar `sam build` e `sam deploy --guided` criar e implantar um aplicativo de produção. Neste exemplo, assumiremos um ambiente de desenvolvimento e usaremos o comando `sam sync` para criar e implantar nosso aplicativo. **nota** O comando `sam sync` é recomendado para ambientes de desenvolvimento. Para saber mais, consulte [Introdução ao uso sam sync para sincronizar com Nuvem AWS](using-sam-cli-sync.md). Antes de executar `sam sync`, verificamos se nosso projeto está configurado corretamente em nosso arquivo `samconfig.toml`. Mais importante ainda, verificamos os valores de `stack_name` e `watch`. Com esses valores especificados em nosso arquivo de configuração, não precisamos fornecê-los na linha de comando. ``` version = 0.1 [default] [default.global.parameters] stack_name = "lambda-streaming-nodejs-app" [default.build.parameters] cached = true parallel = true [default.validate.parameters] lint = true [default.deploy.parameters] capabilities = "CAPABILITY_IAM" confirm_changeset = true resolve_s3 = true s3_prefix = "lambda-streaming-nodejs-app" region = "us-west-2" image_repositories = [] [default.package.parameters] resolve_s3 = true [default.sync.parameters] watch = true [default.local_start_api.parameters] warm_containers = "EAGER" [default.local_start_lambda.parameters] warm_containers = "EAGER" ``` Em seguida, executamos `sam sync` para criar e implantar nosso aplicativo. Como a opção `--watch` está configurada em nosso arquivo de configuração, AWS SAMCLI criará o nosso aplicativo, implantará o nosso aplicativo e observará as alterações. ``` $ sam sync The SAM CLI will use the AWS Lambda, Amazon API Gateway, and AWS StepFunctions APIs to upload your code without performing a CloudFormation deployment. This will cause drift in your CloudFormation stack. **The sync command should only be used against a development stack**. Queued infra sync. Waiting for in progress code syncs to complete... Starting infra sync. Building codeuri: /Users/.../lambda-streaming-nodejs-app/src runtime: nodejs18.x metadata: {} architecture: x86_64 functions: StreamingFunction package.json file not found. Continuing the build without dependencies. Running NodejsNpmBuilder:CopySource Build Succeeded Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpavrzdhgp. Execute the following command to deploy the packaged template sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpavrzdhgp --stack-nameFirst write!
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque vitae mi tincidunt tellus ultricies dignissim id et diam. Morbi pharetra eu nisi et finibus. Vivamus diam nulla, vulputate et nisl cursus, pellentesque vehicula libero. Cras imperdiet lorem ante, non posuere dolor sollicitudin a. Vestibulum ipsum lacus, blandit nec augue id, lobortis dictum urna. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Morbi auctor orci eget tellus aliquam, non maximus massa porta. In diam ante, pulvinar aliquam nisl non, elementum hendrerit sapien. Vestibulum massa nunc, mattis non congue vitae, placerat in quam. Nam vulputate lectus metus, et dignissim erat varius a.
DONE!
START RequestId: 1e4cdf04-60de-4769-b3a2-c1481982deb4 Version: $LATEST END RequestId: 1e4cdf04-60de-4769-b3a2-c1481982deb4 REPORT RequestId: 1e4cdf04-60de-4769-b3a2-c1481982deb4 Duration: 4088.66 ms Billed Duration: 4089 ms Memory Size: 128 MB Max Memory Used: 68 MB Init Duration: 168.45 ms ``` Quando modificamos nosso código de função, AWS SAM CLI detecta instantaneamente e implanta imediatamente nossas alterações. Aqui está um exemplo da saída AWS SAMCLI após as alterações serem feitas em nosso código de função: ``` Syncing Lambda Function StreamingFunction... Building codeuri: /Users/.../lambda-streaming-nodejs-app/src runtime: nodejs18.x metadata: {} architecture: x86_64 functions: StreamingFunction package.json file not found. Continuing the build without dependencies. Running NodejsNpmBuilder:CopySource Finished syncing Lambda Function StreamingFunction. Syncing Layer StreamingFunctione9cfe924DepLayer... SyncFlow [Layer StreamingFunctione9cfe924DepLayer]: Skipping resource update as the content didn't change Finished syncing Layer StreamingFunctione9cfe924DepLayer. ``` Agora podemos usar `sam remote invoke` novamente para interagir com nossa função na nuvem e testar nossas alterações. ### Exemplos do SQS #### Exemplos básicos **Invoque uma fila do Amazon SQS fornecendo o ARN como ID do recurso:** ``` $ sam remote invoke arn:aws:sqs:us-west-2:01234567890:sqs-example-4DonhBsjsW1b --event '{"hello": "world"}' --output json Sending message to SQS queue MySqsQueue { "MD5OfMessageBody": "49dfdd54b01cbcd2d2ab5e9e5ee6b9b9", "MessageId": "4f464cdd-15ef-4b57-bd72-3ad225d80adc", "ResponseMetadata": { "RequestId": "95d39377-8323-5ef0-9223-ceb198bd09bd", "HTTPStatusCode": 200, "HTTPHeaders": { "x-amzn-requestid": "95d39377-8323-5ef0-9223-ceb198bd09bd", "date": "Wed, 08 Nov 2023 23:27:26 GMT", "content-type": "application/x-amz-json-1.0", "content-length": "106", "connection": "keep-alive" }, "RetryAttempts": 0 } }% ``` ### Exemplos de Step Functions #### Exemplos básicos **Invoque uma máquina de estado fornecendo sua ID física como ID de recurso:** Primeiro, usamos `sam list resources` para obter nossa identificação física: ``` $ sam list resources --stack-name state-machine-example --output json [ { "LogicalResourceId": "HelloWorldStateMachine", "PhysicalResourceId": "arn:aws:states:us-west-2:513423067560:stateMachine:HelloWorldStateMachine-z69tFEUx0F66" }, { "LogicalResourceId": "HelloWorldStateMachineRole", "PhysicalResourceId": "simple-state-machine-HelloWorldStateMachineRole-PduA0BDGuFXw" } ] ``` Em seguida, invocamos nossa máquina de estado usando o ID físico como ID do recurso. Transmitimos um evento na linha de comando com a opção `--event`: ``` $ sam remote invoke arn:aws:states:us-west-2:01234567890:stateMachine:HelloWorldStateMachine-z69tFEUx0F66 --event '{"is_developer": true}' Invoking Step Function arn:aws:states:us-west-2:01234567890:stateMachine:HelloWorldStateMachine-z69tFEUx0F66 "Hello Developer World"% ``` **Invoque uma máquina de estado transmitindo um evento vazio:** ``` $ sam remote invoke HelloWorldStateMachine --stack-name state-machine-example Invoking Step Function HelloWorldStateMachine "Hello World"% ``` ## Links relacionados Para obter a documentação relacionada `sam remote invoke` e o uso do AWS SAMCLI, consulte o seguinte: + [sam remote invoke](sam-cli-command-reference-remote-invoke.md) + [AWS SAM CLI solução de problemas](sam-cli-troubleshooting.md) # Automatize os testes de integração local com AWS SAM Embora você possa usar [Introdução aos testes com sam local invoke](using-sam-cli-local-invoke.md) para testar o código manualmente, AWS SAM também permite testar seu código usando testes de integração automatizados. O teste de integração ajuda você a detectar problemas no início do ciclo de desenvolvimento, a melhorar a qualidade do código e a economizar tempo, ao mesmo tempo que reduz os custos. Para criar testes de integração automatizados AWS SAM, primeiro você executa testes nas funções locais do Lambda antes de implantar na nuvem. AWS O comando [Introdução aos testes com sam local start-lambda](using-sam-cli-local-start-lambda.md) inicia um endpoint local que emula o endpoint de invocação do Lambda. Você pode invocá-lo a partir de seus testes automatizados. Como esse endpoint emula o endpoint de invocação do Lamba, você pode escrever testes uma vez e depois executá-los (sem qualquer modificação) na função do Lambda local ou em uma função do Lambda implantada. Você também pode executar os mesmos testes em uma AWS SAM pilha implantada em seu CI/CD pipeline. Como funciona: 1. Inicie o endpoint local do Lambda. Inicie o endpoint local do Lambda executando o seguinte comando no diretório que contém seu modelo: AWS SAM ``` sam local start-lambda ``` Esse comando inicia um endpoint local no `http://127.0.0.1:3001` que emula AWS Lambda. Você pode executar seus testes automatizados nesse endpoint local do Lambda. Quando você invoca esse endpoint usando o AWS CLI ou SDK, ele executa localmente a função Lambda especificada na solicitação e retorna uma resposta. 1. Execute um teste de integração no endpoint Lambda local. Em seu teste de integração, você pode usar o AWS SDK para invocar sua função Lambda com dados de teste, aguardar a resposta e verificar se a resposta é o que você espera. Para executar o teste de integração localmente, você deve configurar o AWS SDK para enviar uma chamada de API Lambda Invoke para invocar o endpoint local do Lambda que você iniciou na etapa anterior. A seguir está um exemplo de Python (as AWS SDKs outras linguagens têm configurações semelhantes): ``` import boto3 import botocore # Set "running_locally" flag if you are running the integration test locally running_locally = True if running_locally: # Create Lambda SDK client to connect to appropriate Lambda endpoint lambda_client = boto3.client('lambda', region_name="us-west-2", endpoint_url="http://127.0.0.1:3001", use_ssl=False, verify=False, config=botocore.client.Config( signature_version=botocore.UNSIGNED, read_timeout=15, retries={'max_attempts': 0}, ) ) else: lambda_client = boto3.client('lambda') # Invoke your Lambda function as you normally usually do. The function will run # locally if it is configured to do so response = lambda_client.invoke(FunctionName="HelloWorldFunction") # Verify the response assert response == "Hello World" ``` Você pode usar esse código para testar as funções do Lambda implantadas configurando `running_locally` como `False`. Isso configura o AWS SDK ao qual se conectar AWS Lambda na AWS nuvem. # Gere amostras de cargas úteis de eventos com AWS SAM Para testar suas funções do Lambda, você pode gerar e personalizar amostras de cargas de eventos que imitam os dados que suas funções do Lambda receberão quando acionadas por outros serviços. AWS Isso inclui serviços como o API Gateway, CloudFormation, Amazon S3 e muito mais. A geração de exemplos de cargas úteis de eventos ajuda você a testar o comportamento da função do Lambda com uma variedade de entradas diferentes sem precisar trabalhar em um ambiente em tempo real. Essa abordagem também economiza tempo quando comparada à criação manual de amostras AWS de eventos de serviço para testar funções. Para ver a lista completa de serviços para os quais você pode gerar amostras de cargas de eventos, use este comando: ``` sam local generate-event --help ``` Para ver a lista de opções que você pode usar para um serviço específico, use este comando: ``` sam local generate-event [SERVICE] --help ``` Exemplos: ``` #Generates the event from S3 when a new object is created sam local generate-event s3 put # Generates the event from S3 when an object is deleted sam local generate-event s3 delete ``` # Testando e depurando funções duráveis Testar e depurar funções duráveis localmente funcionam de forma semelhante às funções normais do Lambda, com suporte automático para checkpoint e replay. Este guia aborda cenários comuns de teste e técnicas de solução de problemas. ## Fluxo de trabalho de teste local Ao testar funções duráveis localmente, o fluxo de trabalho difere das funções normais do Lambda: **Fluxo de trabalho durável de testes de funções** 1. Crie seu aplicativo: ``` $ sam build ``` 1. Invoque sua função durável: ``` $ sam local invoke MyDurableFunction --durable-execution-name test ``` 1. Verifique o histórico de execução, se necessário: ``` $ sam local execution history execution-id ``` ## Cenários de teste comuns ### Testando o comportamento do checkpoint Para testar se sua função corretamente, os pontos de verificação indicam: ``` # Example Python durable function def handler(event, context): # This will create a checkpoint context.wait(10) # Wait 10 seconds # Function resumes here after wait return {"message": "Function resumed after wait"} ``` Quando você invoca essa função localmente, o período de espera é processado automaticamente. ### Testando cenários de retorno de chamada Para funções que aguardam retornos de chamada externos: 1. Inicie sua função durável que aguarda um retorno de chamada 1. Em outro terminal, resolva o retorno de chamada: ``` $ sam local callback succeed callback-id ``` 1. Observe a execução do currículo da função ## Solução de problemas ### Função durável que não está sendo executada corretamente **Problema:** a função não se comporta como uma função durável. **Soluções:** + Verifique se `DurableConfig` está definido no seu modelo de SAM + Certifique-se de que seu código de função use métodos SDK de função duráveis (por exemplo,`context.wait()`) + Verifique se você está usando um tempo de execução compatível (TypeScript, JavaScript, Python) ### Não é possível recuperar o histórico de execução **Problema:** O `local execution history` comando não retorna resultados. **Soluções:** + Verifique se o ID de execução está correto + Verifique se a função foi invocada pelo menos uma vez ### Os comandos de retorno de chamada não funcionam **Problema:** os comandos de retorno de chamada não resolvem operações pendentes. **Soluções:** + Verifique se o ID de retorno de chamada está correto + Verifique se a função está realmente aguardando um retorno de chamada + Verifique se você está usando a sintaxe correta do comando de retorno de chamada ## Dicas de depuração + **Use o histórico de execução** - revise o histórico de execução para entender o fluxo de sua função durável + **Teste incrementalmente** - comece com operações de espera simples antes de adicionar lógica complexa + **Use registro detalhado - Habilite o registro** detalhado para rastrear o fluxo de execução ## Saiba mais Para obter mais informações sobre testes e depuração, consulte: + [Introdução aos testes com sam local invoke](using-sam-cli-local-invoke.md)- Documentação de invocação local + [sam local execution history](sam-cli-command-reference-sam-local-execution-history.md)- Histórico de execução