AWS Cloud9 não está mais disponível para novos clientes. Os clientes atuais do AWS Cloud9 podem continuar usando o serviço normalmente. [Saiba mais](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
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á.
# Trabalhando com AWS SAM o uso do AWS kit de ferramentas
O AWS kit de ferramentas fornece suporte para aplicativos [sem servidor](https://aws.amazon.com/serverless/). Usando o AWS kit de ferramentas, você pode criar aplicativos sem servidor que contêm [AWS Lambda](https://aws.amazon.com/lambda/)funções e, em seguida, implantá-los em uma pilha. AWS CloudFormation
## Criar uma aplicação sem servidor
Este exemplo mostra como usar o AWS Toolkit para criar um aplicativo sem servidor. Para obter informações sobre como executar e depurar aplicações com tecnologia sem servidor, consulte [Executar e depurar aplicações sem servidor](#sam-run-debug).
Os pré-requisitos necessários para criar uma aplicação com tecnologia sem servidor incluem a **CLI do AWS SAM ** e a **CLI da AWS **. Eles estão incluídos com AWS Cloud9. Se a AWS SAM CLI não estiver instalada ou estiver desatualizada, talvez seja necessário executar uma instalação ou atualização. [Para obter instruções sobre como instalar a AWS SAM CLI, consulte [Instalando a AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html#install-sam-cli-instructions) e para obter instruções sobre como atualizar a CLI AWS SAM , consulte Atualizando a CLI. AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade)
### Crie um aplicativo sem servidor com o Toolkit AWS
[Este exemplo mostra como criar um aplicativo sem servidor com o AWS Toolkit usando o AWS Serverless Application Model ().AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)
1. No **AWS Explorer** abra o menu de contexto (clique com o botão direito do mouse) do nó do **Lambda** e, depois, selecione **Create Lambda SAM Application** (Criar aplicação Lambda SAM).
**nota**
Você também pode clicar o ícone de menu no título **AWS: Explorer** e selecionar **Create Lambda SAM Application** (Criar aplicação Lambda SAM).
1. Escolha o tempo de execução para o seu aplicativo SAM. Para este exemplo, escolha **nodejs12.x**.
**nota**
Se você selecionar um dos ambientes de tempo de execução com “(Image)”, sua aplicação será o tipo de pacote `Image`. Se você selecionar um dos ambientes de tempo de execução sem “(Image)”, sua aplicação será o tipo `Zip`. Para obter mais informações sobre a diferença entre o `Image` e os tipos de pacote de `Zip`, consulte [Pacotes de implantação do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) no *Manual do desenvolvedor do AWS Lambda *.
1. Selecione um dos seguintes modelos para a aplicação com tecnologia sem servidor:
+ **AWS SAM Hello World**: um modelo básico com uma função Lambda que retorna a mensagem clássica “Hello World”.
+ **AWS Step Functions Sample App**: Um aplicativo de amostra que executa um fluxo de trabalho de negociação de ações. As funções da etapa orquestram as interações das funções do Lambda envolvidas.
1. Escolha um local para o seu novo projeto. Se houver uma disponível, você poderá selecionar uma pasta do espaço de trabalho existente. Caso contrário, procure uma pasta diferente. Se você selecionar **Select a different folder** (Selecionar uma pasta diferente), uma caixa de diálogo será exibida onde você poderá selecionar um local para a pasta.
1. Insira um nome para a nova aplicação. Neste exemplo, use `my-sam-app-nodejs`. Depois de pressionar **Enter**, o AWS kit de ferramentas leva alguns minutos para criar o projeto.
Quando o projeto for criado, você pode visualizar os arquivos da aplicação na janela Environment (Ambiente). Encontre-o listado na janela do **Explorer**.
![\[Captura de tela mostrando os tempos de execução disponíveis para aplicações SAM.\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/sam-create-app-explorer.png)
## Executar e depurar aplicações sem servidor
Você pode usar o AWS Toolkit para configurar como depurar aplicativos sem servidor e executá-los localmente em seu ambiente de desenvolvimento. Você pode depurar um aplicativo sem servidor definido por um modelo AWS Serverless Application Model ()AWS SAM. Esse modelo usa uma sintaxe YAML simples para descrever recursos como funções APIs, bancos de dados e mapeamentos de origem de eventos que compõem um aplicativo sem servidor.
Para ver mais de perto o AWS SAM modelo, consulte a [anatomia do AWS SAM modelo](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification-template-anatomy.html) no *Guia do AWS Serverless Application Model desenvolvedor*.
Alternativamente, você pode depurar rapidamente as aplicações sem servidor que não foram confirmadas em um modelo SAM.
Você começa a configurar o comportamento de depuração usando ações embutidas para identificar uma função elegível AWS Lambda . Para usar a infraestrutura definida pelo modelo SAM, use a ação integrada ao arquivo relevante, formatado em YAML. Para testar a função diretamente sem o modelo, use o link sensível ao contexto para o manipulador do Lambda no arquivo da aplicação.
**nota**
Neste exemplo, estamos depurando um aplicativo que usa. JavaScript Mas você pode usar os recursos de depuração disponíveis no AWS Toolkit com os seguintes idiomas e tempos de execução:
JavaScript — Node.js 10. *x*, 12. *x*, 14. *x*
Python — 3.7, 3.8, 3.9, 3.10 (os aplicativos sem servidor Python 2.7 e 3.6 podem ser executados, mas não depurados pelo Toolkit.) AWS
Sua escolha de idioma também afeta como os links sensíveis ao contexto indicam manipuladores Lambda qualificados. Para obter mais informações, consulte [Executar e depurar funções sem servidor diretamente do código](#run-debug-no-template).
### Usar modelos SAM para executar e depurar aplicações sem servidor
Para aplicações que são executadas e depuradas usando um modelo SAM, um arquivo formatado em YAML descreve o comportamento da aplicação e os recursos que ele usa. Se você criar um aplicativo sem servidor usando o AWS Toolkit, um arquivo chamado será `template.yaml` gerado automaticamente para o seu projeto.
Neste procedimento, use a aplicação de exemplo criada no [Criar uma aplicação sem servidor](#sam-create).
### Para usar um modelo SAM para executar e depurar uma aplicação sem servidor
1. Para exibir os arquivos da aplicação que compõem a aplicação sem servidor, acesse a janela **Environment** (Ambiente).
1. Na pasta do aplicativo (por exemplo, *my-sample-app*), abra o `template.yaml` arquivo.
1. Em `template.yaml`, selecione **Edit Launch Configuration** (Editar configuração de execução).
Um novo editor exibe o arquivo `launch.json` que fornece uma configuração de depuração com atributos padrão.
1. Edite ou confirme valores para as seguintes propriedades de configuração:
+ `"name"`: insira um nome de leitura fácil para aparecer no campo suspenso **Configuration** (Configuração) na exibição **Run** (Executar).
+ `"target"`: verifique se o valor é `"template"`. Dessa forma, o modelo do SAM é o ponto de entrada para a sessão de depuração.
+ `"templatePath"` – Insira um caminho relativo ou absoluto para o arquivo `template.yaml`.
+ `"logicalId"`: verifique se o nome corresponde ao nome especificado na seção **Resources** (Recursos) do modelo do SAM. Neste caso, é o `HelloWorldFunction` do tipo `AWS::Serverless::Function`.
Para obter mais informações sobre essas e outras entradas no arquivo `launch.json`, consulte [Opções de configuração para depurar aplicações sem servidor](sam-debug-config-ref.md).
1. Se você estiver satisfeito com sua configuração de depuração, salve `launch.json`. Depois, selecione o botão verde “play” (reproduzir) ao lado de **RUN** (Executar) para iniciar a depuração.
**nota**
Se a aplicação SAM falhar ao executar, verifique a janela **Output** (Resultado) para ver se o erro foi causado por uma imagem do Docker que não está sendo compilada. Talvez seja necessário liberar espaço em disco em seu ambiente.
Para obter mais informações, consulte [Erro ao executar aplicativos SAM localmente no AWS Toolkit porque o AWS Cloud9 ambiente não tem espaço em disco suficiente](troubleshooting.md#troubleshooting-dockerimage-toolkit).
Quando as sessões de depuração forem iniciadas, o painel **DEBUG CONSOLE** (Console de depuração) mostrará a saída de depuração e todos os valores retornados pela função do Lambda. Ao depurar aplicações SAM, o **Kit de ferramentas da AWS ** é selecionado como a **Saída** no painel **Saída**.
**nota**
Para usuários do Windows, se você encontrar um erro de montagem do Docker durante esse processo, talvez seja necessário atualizar as credenciais das unidades compartilhadas em **Docker Settings** (Configurações do Docker). Um erro de montagem do Docker terá uma aparência semelhante à seguinte.
```
Fetching lambci/lambda:nodejs10.x Docker container image......
2019-07-12 13:36:58 Mounting C:\Users\\AppData\Local\Temp\ ... as /var/task:ro,delegated inside runtime container
Traceback (most recent call last):
...requests.exceptions.HTTPError: 500 Server Error: Internal Server Error ...
```
### Executar e depurar funções sem servidor diretamente do código
Ao testar o AWS SAM aplicativo, você pode optar por executar e depurar somente a função Lambda. Exclua outros recursos definidos pelo modelo do SAM. Essa abordagem envolve o uso de uma ação integrada para identificar manipuladores de função do Lambda no código-fonte que podem ser diretamente invocados.
Os manipuladores do Lambda que são detectados por links sensíveis ao contexto dependem do idioma e do tempo de execução que você estiver usando para a aplicação.
| Language/runtime | Condições para que as funções do Lambda sejam identificadas por links sensíveis ao contexto |
| --- | --- |
| JavaScript (Node.js 10.x, 12.x e 14.x) | A função de pesquisa também tem os seguintes recursos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/serverless-apps-toolkit.html) |
| Python (3.7, 3.8, 3.9 d 3.10) | A função de pesquisa também tem os seguintes recursos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/serverless-apps-toolkit.html) |
### Para executar e depurar uma aplicação sem servidor diretamente do código da aplicação
1. Para exibir os arquivos da aplicação com tecnologia sem servidor, navegue até a pasta da aplicação selecionando o ícone de pasta ao lado do editor.
1. Na pasta do aplicativo (por exemplo, *my-sample-app*), expanda a pasta de funções (neste exemplo, *hello-world*) e abra o `app.js` arquivo.
1. Na ação integrada que identifica uma função de manipulador do Lambda elegível, escolha `Add Debug Configuration`. Se a opção de adicionar configuração de depuração não for exibida, você deverá ativar as lentes de código. Para habilitar as lentes de código, consulte [Ativando AWS lentes de código do Toolkit](enable-code-lenses.md).
![\[Acesse a opção Add Debug Configuration (Adicionar configuração de depuração) na ação integrada para um manipulador de função do Lambda.\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/direct_invoke_config.png)
1. Selecione o ambiente de tempo de execução no qual a aplicação SAM será executada.
1. No editor para o arquivo `launch.json`, edite ou confirme valores para as seguintes propriedades de configuração:
+ `"name"` – Insira um nome de leitura fácil.
+ `"target"` – Verifique se o valor é `"code"` para que um manipulador de função do Lambda seja diretamente chamado.
+ `"lambdaHandler"` –Insira nome do método no código que o Lambda chama para executar a função. Por exemplo, para aplicativos em JavaScript, o padrão é`app.lambdaHandler`.
+ `"projectRoot"` – Insira o caminho para o arquivo da aplicação que contém a função do Lambda.
+ `"runtime"`: insira ou confirme um ambiente de tempo de execução válido para o ambiente de execução do Lambda, (por exemplo, `"nodejs.12x"`).
+ `"payload"` – Escolha uma das seguintes opções para definir a carga útil do evento que você quer fornecer para a função Lambda como entrada:
+ `"json"`: Pares de chave/valor formatados em JSON que definem a carga útil do evento.
+ `"path"`: Um caminho para o arquivo que é usado como a carga útil do evento.
1.
Se você estiver satisfeito com a configuração de depuração, escolha a seta verde ao lado de **RUN** (Executar) para iniciar a depuração.
Quando as sessões de depuração forem iniciadas, o painel **DEBUG CONSOLE** (Console de depuração) mostrará a saída de depuração e todos os valores retornados pela função do Lambda. Ao depurar aplicações SAM, o **Kit de ferramentas da AWS ** é selecionado como a **Saída** no painel **Saída**.
**nota**
Se você vir o Docker mencionado nas mensagens de erro, consulte esta [anotação](#docker-problem).
### Executar e depurar recursos locais do Amazon API Gateway
Você pode executar ou depurar os recursos locais AWS SAM do API Gateway que estão especificados em`template.yaml`. Faça isso executando uma configuração de AWS Cloud9 inicialização do `type=aws-sam` com `invokeTarget.target=api` o.
**nota**
O API Gateway oferece suporte a dois tipos de APIs. Eles são REST e HTTP APIs. No entanto, o recurso API Gateway com o AWS Toolkit só é compatível com APIs REST. Às vezes, o HTTP APIs é chamado de “API Gateway V2" APIs.
**Para executar e depurar recursos locais do API Gateway**
1. Selecione uma das seguintes abordagens para criar uma configuração de execução para um recurso do API Gateway do AWS SAM :
+ **Opção 1**: acesse o código-fonte do manipulador (especificamente, um arquivo .js, .cs ou .py) no projeto do AWS SAM , passe o mouse sobre o manipulador do Lambda e selecione **Add Debug Configuration** (Adicionar uma configuração de depuração). Se a opção de adicionar configuração de depuração não for exibida, ative as lentes de código. Para habilitar as lentes de código, consulte [Ativando AWS lentes de código do Toolkit](enable-code-lenses.md)). Em seguida, no menu, escolha o item marcado API Event.
+ **Opção 2**: Edite `launch.json` e crie uma nova configuração de execução usando a sintaxe a seguir.
```
{
"type": "aws-sam",
"request": "direct-invoke",
"name": "myConfig",
"invokeTarget": {
"target": "api",
"templatePath": "n12/template.yaml",
"logicalId": "HelloWorldFunction"
},
"api": {
"path": "/hello",
"httpMethod": "post",
"payload": {
"json": {}
}
},
"sam": {},
"aws": {}
}
```
1. No menu suspenso ao lado do botão **Run** (Executar), selecione a configuração de execução (chamada `myConfig` no exemplo acima).
1. (Opcional) Adicione pontos de interrupção ao código do projeto do Lambda.
1. Selecione o **Run** (Executar) ao lado do botão verde **Play**.
1. No painel de saída, exiba os resultados.
#### Configuração
Quando você usa o Valor da propriedade do `invokeTarget.target`, `api`, o Toolkit altera a validação da configuração de execução e o comportamento para suportar um campo da `api`.
```
{
"type": "aws-sam",
"request": "direct-invoke",
"name": "myConfig",
"invokeTarget": {
"target": "api",
"templatePath": "n12/template.yaml",
"logicalId": "HelloWorldFunction"
},
"api": {
"path": "/hello",
"httpMethod": "post",
"payload": {
"json": {}
},
"querystring": "abc=def&qrs=tuv",
"headers": {
"cookie": "name=value; name2=value2; name3=value3"
}
},
"sam": {},
"aws": {}
}
```
Substitua os valores no exemplo da seguinte forma:
**invokeTarget.logicalId**
Um recurso da API.
**caminho**
O caminho da API que a configuração de execução solicita, (por exemplo, `"path": "/hello"`).
Deve ser um caminho de API válido resolvido a partir do `template.yaml` especificado por `invokeTarget.templatePath`.
**httpMethod**
Utilize um dos seguintes verbos: “delete”, “get”, “head”, “options”, “path”, “post”, “put”.
**payload**
A carga útil do JSON (corpo HTTP) a ser enviada na solicitação, com a mesma estrutura e regras que o campo lambda.payload.
O `payload.path` aponta para um arquivo que contém a carga útil JSON.
`payload.json` especifica uma carga útil JSON integrada.
**headers**
Mapa opcional de pares de nome/valor. Use-o para especificar cabeçalhos HTTP a serem incluídos na solicitação.
```
"headers": {
"accept-encoding": "deflate, gzip;q=1.0, *;q=0.5",
"accept-language": "fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5",
"cookie": "name=value; name2=value2; name3=value3",
"user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36",
}
```
**querystring**
(Opcional) Use essa string que define a `querystring` da solicitação, por exemplo, `"querystring": "abc=def&ghi=jkl"`.
**aws**
Como as informações de AWS conexão são fornecidas. Para obter mais informações, consulte a tabela **Propriedades (`aws`) da conexão com a AWS ** no [Opções de configuração para depurar aplicações sem servidor](sam-debug-config-ref.md).
**sam**
Como a AWS SAM CLI cria o aplicativo. Para obter mais informações, consulte as **Propriedades (”`sam`“) da CLI do AWS SAM ** em [Opções de configuração para depurar aplicações sem servidor](sam-debug-config-ref.md).
## Sincronizar uma aplicação sem servidor
Este exemplo mostra como sincronizar a aplicação sem servidor criada no tópico anterior ([Criar uma aplicação sem servidor](#sam-create)) na AWS usando o AWS Toolkit for Visual Studio Code.
### Pré-requisitos
+ Selecione um nome globalmente exclusivo do bucket do Amazon S3.
+ Certifique-se de que as credenciais nas quais você configurou incluam o read/write acesso apropriado aos seguintes serviços: Amazon S3 CloudFormation,, AWS Lambda, e Amazon API Gateway.
+ Para aplicações com implantação do tipo `Image`, tenha um nome de bucket do Amazon S3 globalmente exclusivo e um URI de repositório do Amazon ECR para usar na implantação.
### Sincronizar uma aplicação sem servidor
1. Na janela do **AWS Explorer**, abra o menu de contexto (clique com o botão direito do mouse) do nó do **Lambda** e selecione **Sincronizar a aplicação SAM**.
1. Escolha o Região da AWS para implantar.
1. Escolha o arquivo `template.yaml` a ser usado para a implantação.
1. Insira o nome de um bucket do Amazon S3 a ser utilizado nessa implantação. O bucket deve estar na região na qual você estiver implantando.
**Atenção**
Esse nome de bucket do Amazon S3 deve ser exclusivo globalmente com relação a todos os nomes de buckets existentes no Amazon S3. Adicione um identificador exclusivo ao nome fornecido no exemplo a seguir ou selecione outro nome.
1. Se a aplicação sem servidor incluir uma função com o tipo de pacote `Image`, insira o nome de um repositório do Amazon ECR que essa implantação pode usar. O repositório deve estar na região na qual você estiver implantando.
1. Insira um nome, novo ou existente, para a pilha implantada.
1. Verifique o êxito da implantação na guia **AWS Toolkit** do **Console**.
Se ocorrer um erro, uma mensagem será exibida na parte inferior direita.
Se isso acontecer, verifique o texto na guia **AWS Toolkit** para obter detalhes. Veja a seguir um exemplo de detalhes de erro.
```
Error with child process: Unable to upload artifact HelloWorldFunction referenced by CodeUri parameter of HelloWorldFunction resource.
S3 Bucket does not exist. Execute the command to create a new bucket
aws s3 mb s3://pbart-my-sam-app-bucket
An error occurred while deploying a SAM Application. Check the logs for more information by running the "View AWS Toolkit Logs" command from the Command Palette.
```
Neste exemplo, o erro ocorreu porque o bucket do Amazon S3 não existia.
Depois de concluir a implantação, seu aplicativo será listado na janela do **AWS Explorer**. Para saber como invocar a função do Lambda criada como parte da aplicação, consulte [Invocar funções do Lambda remotas](lambda-toolkit.md#remote-lambda).
## Excluindo um aplicativo sem servidor da nuvem AWS
A exclusão de um aplicativo sem servidor envolve a exclusão da CloudFormation pilha que você implantou anteriormente na nuvem. AWS Observe que esse procedimento não exclui o diretório da aplicação do host local.
1. Abra o **AWS Explorer**.
1. Na janela do **AWS Explorer**, expanda a região que contém a aplicação implantada que você deseja excluir e, em seguida, expanda o **CloudFormation**.
1. Abra o menu de contexto (clique com o botão direito do mouse) do nome da CloudFormation pilha que corresponde ao aplicativo sem servidor que você deseja excluir. Em seguida, escolha **Excluir CloudFormation pilha**.
1. Para confirmar que deseja excluir a pilha selecionada, escolha **Delete** (Excluir).
**Se a exclusão da pilha for bem-sucedida, o AWS Toolkit removerá o nome da pilha da lista no Explorer. CloudFormation AWS **
# Ativando AWS lentes de código do Toolkit
Esta etapa mostra como você pode ativar as lentes de código do AWS Toolkit.
1. Na barra de menu, escolha **AWS Cloud9** e **Preferences** (Preferências).
1. Na guia **Preferences** (Preferências), na barra lateral, escolha **AWS Toolkit**.
1. Para habilitar lentes de código, escolha **Enable Code Lenses** (Habilitar lentes de código).
# Opções de configuração para depurar aplicações sem servidor
Com ações integradas, você pode facilmente encontrar e definir propriedades para invocar funções do Lambda diretamente ou com o modelo SAM. Você também pode definir propriedades para `"lambda"` (como a função é executada), `"sam"` (como a AWS SAM CLI cria o aplicativo) e `"aws"` (como as informações de AWS conexão são fornecidas).
**AWS SAM: Invocação direta do manipulador Lambda/Invocação Lambda baseada em modelo**
| Propriedade | Description |
| --- | --- |
| `type` | Especifica qual extensão gerencia a configuração de inicialização. Sempre configure para usar `aws-sam` a AWS SAM CLI para criar e depurar localmente. |
| `name` | Especifica um nome compatível com o leitor a ser exibido na lista **Debug launch configuration** (Configuração de execução da depuração). |
| `request` | Especifica o tipo de configuração a ser executada pela extensão designada (`aws-sam`). Sempre definido como `direct-invoke` para iniciar a função do Lambda. |
| `invokeTarget` | Especifica o ponto de entrada para invocar o recurso. Para invocar a função Lambda diretamente, defina valores para os seguintes campos de `invokeTarget`: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/sam-debug-config-ref.html) Para invocar os recursos do Lambda com o modelo do SAM, defina os valores para os seguintes campos de `invokeTarget`: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/sam-debug-config-ref.html) |
**Propriedades do Lambda (`"lambda"`)**
| Propriedade | Description |
| --- | --- |
| `environmentVariables` | Transmite parâmetros operacionais para a função. Por exemplo, se você estiver gravando em um bucket do Amazon S3, configure o nome do bucket como uma variável de ambiente. Não codifique o nome do bucket no qual você está gravando. |
| `payload` | Fornece duas opções para a carga útil de eventos que você fornece para a função Lambda como entrada. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/sam-debug-config-ref.html) |
| `memoryMB` | Especifica os megabytes de memória fornecidos para executar uma função do Lambda chamada. |
| `runtime` | O tempo de execução do usado pela função do Lambda. Para obter mais informações, consulte [Tempos de execução do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). |
| `timeoutSec` | Define o tempo permitido, em segundos, antes que a sessão de depuração seja encerrada. |
A extensão AWS Toolkit usa a AWS SAM CLI para criar e depurar aplicativos sem servidor localmente. Você pode configurar o comportamento dos comandos da AWS SAM CLI usando as propriedades da `"sam"` configuração no `launch.json` arquivo.
**AWS SAM Propriedades da CLI () `"sam"`**
| Propriedade | Description | Valor padrão |
| --- | --- | --- |
| `buildArguments` | Configura como o `sam build` constrói o código-fonte do Lambda. Para visualizar opções de compilação, consulte [sam build](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html) no *Manual do desenvolvedor do AWS Serverless Application Model *. | String vazia |
| `containerBuild` | Indica se sua função deve ser construída dentro de um AWS Lambda contêiner Docker semelhante a. | `false` |
| `dockerNetwork` | Especifica o nome ou ID de uma rede Docker existente à qual os contêineres do Docker do Lambda devem se conectar, juntamente com a rede de ponte padrão. Se não for especificado, os contêineres do Lambda se conectarão somente à rede de Docker de ponte padrão. | String vazia |
| `localArguments` | Argumentos de invocação local adicionais. | String vazia |
| `skipNewImageCheck` | Especifica se o comando deve ignorar a extração da imagem mais recente do Docker para o tempo de execução do Lambda. | `false` |
| `template` | Personaliza seu modelo SAM usando parâmetros para inserir valores do cliente nele. Para obter mais informações, consulte [Parâmetros](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html) no *Guia do usuário do AWS CloudFormation *. | `"parameters":{}` |
**AWS propriedades de conexão (`"aws"`)**
| Propriedade | Description | Valor padrão |
| --- | --- | --- |
| `credentials` | Seleciona um perfil específico (por exemplo,`profile:default`) do seu arquivo de credenciais para obter AWS as credenciais. | As AWS credenciais fornecidas pelo seu arquivo de AWS configuração compartilhado existente ou arquivo de AWS credenciais compartilhado. |
| `Region` | Define a AWS região do serviço (por exemplo, us-east-1). | A AWS região padrão associada ao perfil de credenciais ativo. |