Pré-requisitos Etapa 1: Inicialize o aplicativo de amostra Hello World Etapa 2: crie seu aplicativo Etapa 3: implantar seu aplicativo no Nuvem AWS Etapa 4: Executar seu aplicativo Etapa 5: Interaja com sua função no Nuvem AWS Etapa 6: Modifique e sincronize seu aplicativo com o Nuvem AWS Etapa 7: (opcional) Teste seu aplicativo localmente Etapa 8: Excluir seu aplicativo do Nuvem AWS Solução de problemas Saiba mais

Tutorial: Implantando um aplicativo Hello World

Neste tutorial, você usa a AWS Serverless Application Model interface de linha de comando (AWS SAM CLI) para completar o seguinte:

Inicialize, crie e implante uma amostra do aplicativo Hello World.
Faça alterações locais e sincronize com o AWS CloudFormation.
Teste seu aplicativo no Nuvem AWS.
Opcionalmente, realize testes locais em seu host de desenvolvimento.
Exclua a amostra do aplicativo do Nuvem AWS.

A amostra do aplicativo Hello World implementa um backend básico da API. É composto pelos seguintes recursos:

Amazon API Gateway — Endpoint de API que você usará para invocar sua função.
AWS Lambda— Função que processa a solicitação GET da API HTTP e retorna uma mensagem hello world.
AWS Identity and Access ManagementPerfil do IAM — Fornece permissões para que os serviços interajam com segurança.

O diagrama a seguir mostra os componentes deste aplicativo:

Um diagrama de uma função do Lambda que é invocada quando você envia uma solicitação GET ao endpoint do API Gateway.

Tópicos

Pré-requisitos
Etapa 1: Inicialize o aplicativo de amostra Hello World
Etapa 2: crie seu aplicativo
Etapa 3: implantar seu aplicativo no Nuvem AWS
Etapa 4: Executar seu aplicativo
Etapa 5: Interaja com sua função no Nuvem AWS
Etapa 6: Modifique e sincronize seu aplicativo com o Nuvem AWS
Etapa 7: (opcional) Teste seu aplicativo localmente
Etapa 8: Excluir seu aplicativo do Nuvem AWS
Solução de problemas
Saiba mais

Pré-requisitos

Verifique se você concluiu o seguinte:

Etapa 1: Inicialize o aplicativo de amostra Hello World

Nesta etapa, você usará o AWS SAM CLI para criar uma amostra de projeto de aplicativo Hello World em sua máquina local.

Para inicializar o aplicativo Hello World de amostra

Na sua linha de comando, execute o seguinte a partir de um diretório inicial de sua escolha:
```
$ sam init
```

O AWS SAMCLI guiará na inicialização de um novo aplicativo. Configure o seguinte:

Selecione AWSModelos de início rápido para escolher um modelo inicial.
Escolha o modelo Hello World Example e baixe-o.
Use o tempo de execuçãoPython e o tipo de pacote zip.
Para este tutorial, desative o rastreamento AWS X-Ray. Para saber mais, consulte O que é AWS X-Ray? no AWS X-RayGuia do desenvolvedor.
Para este tutorial, desative o monitoramento com o Amazon CloudWatch Application Insights. Para saber mais, consulte Amazon CloudWatch Application Insights no Guia CloudWatch do usuário da Amazon.
Nomeie seu aplicativo como sam-app.

Para usar o AWS SAM CLI fluxo interativo:

Os colchetes ([ ]) indicam valores padrão. Deixe sua resposta em branco para selecionar o valor padrão.
Digite y para sim e n para não.

A seguir está um exemplo do sam init fluxo interativo:


$ sam init
...
Which template source would you like to use?
    1 - AWS Quick Start Templates
    2 - Custom Template Location
Choice: 1

Choose an AWS Quick Start application template
    1 - Hello World Example
    2 - Multi-step workflow
    3 - Serverless API
    4 - Scheduled task
    5 - Standalone function
    6 - Data processing
    7 - Hello World Example With Powertools
    8 - Infrastructure event management
    9 - Serverless Connector Hello World Example
    10 - Multi-step workflow with Connectors
    11 - Lambda EFS example
    12 - DynamoDB Example
    13 - Machine Learning
Template: 1

Use the most popular runtime and package type? (Python and zip) [y/N]: y

Would you like to enable X-Ray tracing on the function(s) in your application?  [y/N]: ENTER

Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER

Project name [sam-app]: ENTER

O AWS SAM CLI baixa seu modelo inicial e cria a estrutura de diretórios do projeto do aplicativo em sua máquina local. A seguir, veja um exemplo da saída AWS SAM CLI:

Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)

    -----------------------
    Generating application:
    -----------------------
    Name: sam-app
    Runtime: python3.9
    Architectures: x86_64
    Dependency Manager: pip
    Application Template: hello-world
    Output Directory: .
    Configuration file: sam-app/samconfig.toml

    Next steps can be found in the README file at sam-app/README.md


Commands you can use next
=========================
[*] Create pipeline: cd sam-app && sam pipeline init --bootstrap
[*] Validate SAM template: cd sam-app && sam validate
[*] Test Function in the Cloud: cd sam-app && sam sync --stack-name {stack-name} --watch

Na sua linha de comando, vá para o diretório sam-app recém-criado. Veja a seguir um exemplo do que o AWS SAM CLI criou:


$ cd sam-app

$ tree

├── README.md
├── __init__.py
├── events
│   └── event.json
├── hello_world
│   ├── __init__.py
│   ├── app.py
│   └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
    ├── __init__.py
    ├── integration
    │   ├── __init__.py
    │   └── test_api_gateway.py
    ├── requirements.txt
    └── unit
        ├── __init__.py
        └── test_handler.py
        
6 directories, 14 files

Alguns arquivos importantes a serem destacados:

hello_world/app.py— Contém o código da função do Lambda.
hello_world/requirements.txt— Contém todas as dependências Python que sua função do Lambda exige.
samconfig.toml— Arquivo de configuração do seu aplicativo que armazena os parâmetros padrão usados pelo AWS SAM CLI.
template.yaml— O modelo AWS SAM que contém o código da infraestrutura do seu aplicativo.

Agora você tem um aplicativo com tecnologia sem servidor totalmente criado em sua máquina local!

Etapa 2: crie seu aplicativo

Nesta etapa, você usa o AWS SAM CLI para criar seu aplicativo e se preparar para a implantação. Quando você cria, o AWS SAM CLI cria um diretório .aws-sam e organiza as dependências da função, o código do projeto e os arquivos do projeto nele.

Para construir seu aplicativo

Na sua linha de comando, no diretório do projeto sam-app, execute o seguinte:


$ sam build

nota

Se você não tiver o Python na sua máquina local, use o comando sam build --use-container em vez disso. O AWS SAMCLI criará um contêiner Docker que inclui o tempo de execução as dependências da sua função. Esse comando exige o Docker na sua máquina local. Para instalar Docker, consulte Instalação do Docker.

A seguir, veja um exemplo da saída AWS SAM CLI:


$ sam build
Starting Build use cache
Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../Demo/sam-tutorial1/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Running PythonPipBuilder:CopySource

Build Succeeded

Built Artifacts  : .aws-sam/build
Built Template   : .aws-sam/build/template.yaml

Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided

Veja a seguir um exemplo abreviado do diretório .aws-sam criado pela CLI AWS SAM:

.aws-sam
├── build
│   ├── HelloWorldFunction
│   │   ├── __init__.py
│   │   ├── app.py
│   │   └── requirements.txt
│   └── template.yaml
└── build.toml

Alguns arquivos importantes a serem destacados:

build/HelloWorldFunction— – Contém o código da função do Lambda e as dependências. O AWS SAM CLI cria um diretório para cada função em seu aplicativo.
build/template.yaml— Contém uma cópia do seu modelo AWS SAM que é referenciada pelo AWS CloudFormation na implantação.
build.toml— Arquivo de configuração que armazena valores de parâmetros padrão referenciados pelo AWS SAM CLI ao criar e implantar seu aplicativo.

Agora você está pronto para implantar seu aplicativo no Nuvem AWS.

Etapa 3: implantar seu aplicativo no Nuvem AWS

nota

Essa etapa requer configuração de credenciais AWS. Para obter mais informações, consulte Etapa 5: use o AWS CLI para configurar as credenciais AWS em Pré-requisitos da AWS SAM.

Nesta etapa, você usa o AWS SAM CLI para implantar seu aplicativo no Nuvem AWS. O AWS SAM CLI fará o seguinte:

Orientá-lo na definição das configurações do seu aplicativo para implantação.
Faça o upload dos arquivos do seu aplicativo no Amazon Simple Storage Service (Amazon S3).
Transforme seu modelo AWS SAM em um modelo AWS CloudFormation. Em seguida, ele carrega seu modelo no serviço AWS CloudFormation para fornecer seus recursos AWS.

Para implantar seu aplicativo

Na sua linha de comando, no diretório do projeto sam-app, execute o seguinte:
```
$ sam deploy --guided
```
Siga o fluxo AWS SAM CLI interativo para definir as configurações do aplicativo. Configure o seguinte:
1. O AWS CloudFormationnome da pilha – Uma pilha é um conjunto de recursos da AWS que você pode gerenciar como uma única unidade. Para saber mais, consulte Como trabalhar com pilhas no Guia do AWS CloudFormation usuário.
2. O Região da AWS para implantar sua pilha AWS CloudFormation. Para obter mais informações, consulte AWS CloudFormationEndpoints no AWS CloudFormationGuia do usuário.
3. Neste tutorial, desative confirmar as alterações antes da implantação.
4. Permitir a criação de perfil do IAM — Isso permite que o AWS SAM crie a função do IAM necessária para que o recurso do API Gateway e o recurso da função do Lambda interajam.
5. Neste tutorial, desative a desativação da reversão.
6. Permitir HelloWorldFunction sem autorização definida — Essa mensagem é exibida porque seu endpoint do API Gateway está configurado para ser acessível ao público, sem autorização. Como essa é a configuração pretendida para seu aplicativo Hello World, permita que o AWS SAM CLI continue. Para obter mais informações sobre a autorização, consulte Controlar o acesso às APIs do API Gateway.
7. Salvar argumentos no arquivo de configuração — Isso atualizará o arquivo samconfig.toml do seu aplicativo com suas preferências de implantação.
8. Selecione o nome do arquivo de configuração padrão.
9. Selecione o ambiente de configuração padrão.
Veja a seguir um exemplo de saída do sam deploy --guided fluxo interativo:
```
$ sam-app sam deploy --guided

Configuring SAM deploy
======================

    Looking for config file [samconfig.toml] :  Found
    Reading default arguments  :  Success

    Setting default arguments for 'sam deploy'
    =========================================
    Stack Name [sam-app]: ENTER
    AWS Region [us-west-2]: ENTER
    #Shows you resources changes to be deployed and require a 'Y' to initiate deploy
    Confirm changes before deploy [Y/n]: n
    #SAM needs permission to be able to create roles to connect to the resources in your template
    Allow SAM CLI IAM role creation [Y/n]: ENTER
    #Preserves the state of previously provisioned resources when an operation fails
    Disable rollback [y/N]: ENTER
    HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
    Save arguments to configuration file [Y/n]: ENTER
    SAM configuration file [samconfig.toml]: ENTER
    SAM configuration environment [default]: ENTER
```

O AWS SAM CLI implanta seu aplicativo fazendo o seguinte:

O AWS SAM CLI cria um bucket do Amazon S3 e carrega seu diretório .aws-sam.
O AWS SAM CLI transforma seu modelo AWS SAM em AWS CloudFormation e o carrega no serviço AWS CloudFormation.
AWS CloudFormation fornece seus recursos.

Durante a implantação, o AWS SAM CLI exibe seu progresso. Veja a seguir um exemplo de saída:

Looking for resources needed for deployment:

    Managed S3 bucket: aws-sam-cli-managed-default-samclisourcebucket-1a4x26zbcdkqr
    A different default S3 bucket can be set in samconfig.toml

    Parameter "stack_name=sam-app" in [default.deploy.parameters] is defined as a global parameter [default.global.parameters].
    This parameter will be only saved under [default.global.parameters] in /Users/.../Demo/sam-tutorial1/sam-app/samconfig.toml.

    Saved arguments to config file
    Running 'sam deploy' for future deployments will use the parameters saved above.
    The above parameters can be changed by modifying samconfig.toml
    Learn more about samconfig.toml syntax at
    https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html

File with same data already exists at sam-app/da3c598813f1c2151579b73ad788cac8, skipping upload

    Deploying with following values
    ===============================
    Stack name                   : sam-app
    Region                       : us-west-2
    Confirm changeset            : False
    Disable rollback             : False
    Deployment s3 bucket         : aws-sam-cli-managed-default-samclisourcebucket-1a4x26zbcdkqr
    Capabilities                 : ["CAPABILITY_IAM"]
    Parameter overrides          : {}
    Signing Profiles             : {}

Initiating deployment
=====================

File with same data already exists at sam-app/2bebf67c79f6a743cc5312f6dfc1efee.template, skipping upload


Waiting for changeset to be created..

CloudFormation stack changeset
---------------------------------------------------------------------------------------------------------------------------------------------
Operation                           LogicalResourceId                   ResourceType                        Replacement
---------------------------------------------------------------------------------------------------------------------------------------------
* Modify                            HelloWorldFunction                  AWS::Lambda::Function               False
* Modify                            ServerlessRestApi                   AWS::ApiGateway::RestApi            False
- Delete                            AwsSamAutoDependencyLayerNestedSt   AWS::CloudFormation::Stack          N/A
                                    ack
---------------------------------------------------------------------------------------------------------------------------------------------


Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1678917603/22e05525-08f9-4c52-a2c4-f7f1fd055072


2023-03-15 12:00:16 - Waiting for stack create/update to complete

CloudFormation events from stack operations (refresh every 0.5 seconds)
---------------------------------------------------------------------------------------------------------------------------------------------
ResourceStatus                      ResourceType                        LogicalResourceId                   ResourceStatusReason
---------------------------------------------------------------------------------------------------------------------------------------------
UPDATE_IN_PROGRESS                  AWS::Lambda::Function               HelloWorldFunction                  -
UPDATE_COMPLETE                     AWS::Lambda::Function               HelloWorldFunction                  -
UPDATE_COMPLETE_CLEANUP_IN_PROGRE   AWS::CloudFormation::Stack          sam-app                             -
SS
DELETE_IN_PROGRESS                  AWS::CloudFormation::Stack          AwsSamAutoDependencyLayerNestedSt   -
                                                                        ack
DELETE_COMPLETE                     AWS::CloudFormation::Stack          AwsSamAutoDependencyLayerNestedSt   -
                                                                        ack
UPDATE_COMPLETE                     AWS::CloudFormation::Stack          sam-app                             -
---------------------------------------------------------------------------------------------------------------------------------------------

CloudFormation outputs from deployed stack
----------------------------------------------------------------------------------------------------------------------------------------------
Outputs
----------------------------------------------------------------------------------------------------------------------------------------------
Key                 HelloWorldFunctionIamRole
Description         Implicit IAM Role created for Hello World function
Value               arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-15GLOUR9LMT1W

Key                 HelloWorldApi
Description         API Gateway endpoint URL for Prod stage for Hello World function
Value               https://<restapiid>.execute-api.us-west-2.amazonaws.com/Prod/hello/

Key                 HelloWorldFunction
Description         Hello World Lambda Function ARN
Value               arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-yQDNe17r9maD
----------------------------------------------------------------------------------------------------------------------------------------------


Successfully created/updated stack - sam-app in us-west-2

Seu aplicativo agora está implantado e sendo executado no Nuvem AWS!

Etapa 4: Executar seu aplicativo

Nesta etapa, você enviará uma solicitação GET para o endpoint da API e verá a saída da função do Lambda.

Para obter o valor do endpoint da sua API

A partir das informações exibidas pelo AWS SAM CLI na etapa anterior, localize a seção Outputs. Nesta seção, localize seu recurso HelloWorldApi para encontrar o valor do endpoint HTTP. Veja a seguir um exemplo de saída:

----------------------------------------------------------------------------------------------------------------------------------------------
Outputs
----------------------------------------------------------------------------------------------------------------------------------------------
...
Key                 HelloWorldApi
Description         API Gateway endpoint URL for Prod stage for Hello World function
Value               https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/
...
----------------------------------------------------------------------------------------------------------------------------------------------

É possível também usar o comando sam list endpoints --output json para obter essas informações. Veja a seguir um exemplo de saída:


$ sam list endpoints --output json
2023-03-15 12:39:19 Loading policies from IAM...
2023-03-15 12:39:25 Finished loading policies from IAM.
[
  {
    "LogicalResourceId": "HelloWorldFunction",
    "PhysicalResourceId": "sam-app-HelloWorldFunction-yQDNe17r9maD",
    "CloudEndpoint": "-",
    "Methods": "-"
  },
  {
    "LogicalResourceId": "ServerlessRestApi",
    "PhysicalResourceId": "ets1gv8lxi",
    "CloudEndpoint": [
      "https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod",
      "https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Stage"
    ],
    "Methods": [
      "/hello['get']"
    ]
  }
]

Para invocar sua função

Usando seu navegador ou a linha de comando, envie uma solicitação GET para o endpoint da API. Veja a seguir um exemplo usando o comando curl:
```
$ curl https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/
{"message": "hello world"}
```

Etapa 5: Interaja com sua função no Nuvem AWS

Nesta etapa, você usa o AWS SAM CLI para invocar sua função do Lambda no Nuvem AWS.

Para invocar sua função do Lambda na nuvem

Anote o LogicalResourceId das suas funções na etapa anterior. Deveria ser HelloWorldFunction.
Na sua linha de comando, no diretório do projeto sam-app, execute o seguinte:
```
$ sam remote invoke HelloWorldFunction --stack-name sam-app
```

O AWS SAM CLI invoca sua função na nuvem e retorna uma resposta. Veja a seguir um exemplo de saída:


$ sam remote invoke HelloWorldFunction --stack-name sam-app

Invoking Lambda Function HelloWorldFunction                                       
START RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 Version: $LATEST
END RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9
REPORT RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9  Duration: 6.62 ms       Billed Duration: 7 ms     Memory Size: 128 MB     Max Memory Used: 67 MB  Init Duration: 164.06 ms
{"statusCode":200,"body":"{\"message\":\"hello world\"}"}%

Etapa 6: Modifique e sincronize seu aplicativo com o Nuvem AWS

Nesta etapa, você usa o comando AWS SAM CLI sam sync --watch para sincronizar as alterações locais com o Nuvem AWS.

Para usar o sam sync

Na sua linha de comando, no diretório do projeto sam-app, execute o seguinte:
```
$ sam sync --watch
```

O AWS SAMCLI solicita que você confirme que está sincronizando uma pilha de desenvolvimento. Como o comando sam sync --watch implanta automaticamente as alterações locais no Nuvem AWS em tempo real, nós o recomendamos somente para ambientes de desenvolvimento.

O AWS SAM CLI executa uma implantação inicial antes de começar a monitorar as alterações locais. Veja a seguir um exemplo de saída:


$ sam sync --watch
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**.

Confirm that you are synchronizing a development stack.

Enter Y to proceed with the command, or enter N to cancel:
 [Y/n]: y
Queued infra sync. Waiting for in progress code syncs to complete...
Starting infra sync.
Manifest is not changed for (HelloWorldFunction), running incremental build
Building codeuri: /Users/.../Demo/sam-tutorial1/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CopySource

Build Succeeded

Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpq3x9vh63.
Execute the following command to deploy the packaged template
sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpq3x9vh63 --stack-name <YOUR STACK NAME>


    Deploying with following values
    ===============================
    Stack name                   : sam-app
    Region                       : us-west-2
    Disable rollback             : False
    Deployment s3 bucket         : aws-sam-cli-managed-default-samclisourcebucket-1a4x26zbcdkqr
    Capabilities                 : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
    Parameter overrides          : {}
    Signing Profiles             : null

Initiating deployment
=====================


2023-03-15 13:10:05 - Waiting for stack create/update to complete

CloudFormation events from stack operations (refresh every 0.5 seconds)
---------------------------------------------------------------------------------------------------------------------------------------------
ResourceStatus                      ResourceType                        LogicalResourceId                   ResourceStatusReason
---------------------------------------------------------------------------------------------------------------------------------------------
UPDATE_IN_PROGRESS                  AWS::CloudFormation::Stack          sam-app                             Transformation succeeded
CREATE_IN_PROGRESS                  AWS::CloudFormation::Stack          AwsSamAutoDependencyLayerNestedSt   -
                                                                        ack
CREATE_IN_PROGRESS                  AWS::CloudFormation::Stack          AwsSamAutoDependencyLayerNestedSt   Resource creation Initiated
                                                                        ack
CREATE_COMPLETE                     AWS::CloudFormation::Stack          AwsSamAutoDependencyLayerNestedSt   -
                                                                        ack
UPDATE_IN_PROGRESS                  AWS::Lambda::Function               HelloWorldFunction                  -
UPDATE_COMPLETE                     AWS::Lambda::Function               HelloWorldFunction                  -
UPDATE_COMPLETE_CLEANUP_IN_PROGRE   AWS::CloudFormation::Stack          sam-app                             -
SS
UPDATE_COMPLETE                     AWS::CloudFormation::Stack          sam-app                             -
---------------------------------------------------------------------------------------------------------------------------------------------

CloudFormation outputs from deployed stack
----------------------------------------------------------------------------------------------------------------------------------------------
Outputs
----------------------------------------------------------------------------------------------------------------------------------------------
Key                 HelloWorldFunctionIamRole
Description         Implicit IAM Role created for Hello World function
Value               arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-15GLOUR9LMT1W

Key                 HelloWorldApi
Description         API Gateway endpoint URL for Prod stage for Hello World function
Value               https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/

Key                 HelloWorldFunction
Description         Hello World Lambda Function ARN
Value               arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-yQDNe17r9maD
----------------------------------------------------------------------------------------------------------------------------------------------


Stack update succeeded. Sync infra completed.

Infra sync completed.
CodeTrigger not created as CodeUri or DefinitionUri is missing for ServerlessRestApi.

Depois, você modificará o código da função do Lambda. O AWS SAM CLI detectará automaticamente essa alteração e sincronizará seu aplicativo com o Nuvem AWS.

Para modificar e sincronizar seu aplicativo

No IDE de sua preferência, abra o arquivo sam-app/hello_world/app.py.

Altere o message e salve o arquivo. Veja um exemplo a seguir.


import json
...
def lambda_handler(event, context):
    ...
    return {
        "statusCode": 200,
        "body": json.dumps({
            "message": "hello everyone!",
            ...
        }),
    }

O AWS SAM CLI detecta sua alteração e sincroniza seu aplicativo com o Nuvem AWS. Veja a seguir um exemplo de saída:

Syncing Lambda Function HelloWorldFunction...
Manifest is not changed for (HelloWorldFunction), running incremental build
Building codeuri: /Users/.../Demo/sam-tutorial1/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CopySource
Finished syncing Lambda Function HelloWorldFunction.

Para verificar sua alteração, envie novamente uma solicitação GET para o endpoint da API.


$ curl https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/
{"message": "hello everyone!"}

Etapa 7: (opcional) Teste seu aplicativo localmente

nota

Essa etapa é opcional, pois requer o Docker em sua máquina local.

Importante

Para usar o AWS SAM CLI para testes locais, você deve ter o Docker instalado e configurado. Para obter mais informações, consulte Instalação do Docker.

Nesta etapa, você usa o comando AWS SAM CLI sam local para testar seu aplicativo localmente. Para fazer isso, o AWS SAM CLI cria um ambiente local usando o Docker. Esse ambiente local emula o ambiente de execução baseado em nuvem da sua função do Lambda.

Você fará o seguinte:

Crie um ambiente local para sua função do Lambda e invoque-o.
Hospede o endpoint da sua API HTTP localmente e use-o para invocar sua função do Lambda.

Para invocar a função do Lambda localmente

Na sua linha de comando, no diretório do projeto sam-app, execute o seguinte:
```
$ sam local invoke
```

AWS SAMCLI Isso cria um contêiner Docker local e invoca sua função. Veja a seguir um exemplo de saída:


$ sam local invoke
Invoking app.lambda_handler (python3.9)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-python3.9
Building image.....................
Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.

Mounting /Users/.../Demo/sam-tutorial1/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container
START RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6 Version: $LATEST
END RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6
REPORT RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6    Init Duration: 1.01 ms    Duration: 633.45 ms    Billed Duration: 634 ms    Memory Size: 128 MB    Max Memory Used: 128 MB
{"statusCode": 200, "body": "{\"message\": \"hello world\"}"}

Para hospedar sua API localmente

Na sua linha de comando, no diretório do projeto sam-app, execute o seguinte:
```
$ sam local start-api
```

O AWS SAM CLI cria um contêiner Docker local para sua função do Lambda e cria um servidor HTTP local para simular o endpoint da sua API. Veja a seguir um exemplo de saída:


$ 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/.../Demo/sam-tutorial1/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-03-15 14:25:21 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-03-15 14:25:21 Press CTRL+C to quit

Usando seu navegador ou a linha de comando, envie uma solicitação GET para o endpoint da API local. Veja a seguir um exemplo usando o comando curl:
```
$ curl http://127.0.0.1:3000/hello
{"message": "hello world"}
```

Etapa 8: Excluir seu aplicativo do Nuvem AWS

Nesta etapa, você usa o AWS SAM CLI sam delete comando para excluir seu aplicativo do arquivo Nuvem AWS.

Para excluir seu aplicativo do Nuvem AWS

Na sua linha de comando, no diretório do projeto sam-app, execute o seguinte:
```
$ sam delete
```

O AWS SAM CLI pedirá que você confirme. Em seguida, ele excluirá o bucket e a pilha AWS CloudFormation do Amazon S3 do seu aplicativo. Veja a seguir um exemplo de saída:


$ sam delete
    Are you sure you want to delete the stack sam-app in the region us-west-2 ? [y/N]: y
    Are you sure you want to delete the folder sam-app in S3 which contains the artifacts? [y/N]: y
    - Deleting S3 object with key c6ce8fa8b5a97dd022ecd006536eb5a4
    - Deleting S3 object with key 5d513a459d062d644f3b7dd0c8b56a2a.template
    - Deleting S3 object with key sam-app/2bebf67c79f6a743cc5312f6dfc1efee.template
    - Deleting S3 object with key sam-app/6b208d0e42ad15d1cee77d967834784b.template
    - Deleting S3 object with key sam-app/da3c598813f1c2151579b73ad788cac8
    - Deleting S3 object with key sam-app/f798cdd93cee188a71d120f14a035b11
    - Deleting Cloudformation stack sam-app

Deleted successfully

Solução de problemas

Para solucionar problemas do AWS SAM CLI, consulte AWS SAM CLI solução de problemas.

Saiba mais

Para continuar aprendendo sobre o AWS SAM, consulte os seguintes recursos:

O Workshop AWS SAM Completo – Um workshop projetado para ensinar a você muitos dos principais atributos que AWS SAM oferece.
Sessões com o SAM – Série de vídeos criada por nossa equipe AWS Serverless Developer Advocate sobre o uso de AWS SAM.
Serverless Land — Site que reúne as informações mais recentes, blogs, vídeos, código e recursos de aprendizado para a tecnologia sem servidor AWS.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Instalando o AWS SAM CLI

Usar o AWS SAM