

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á.

# Crie seu aplicativo em AWS SAM
<a name="using-sam-cli-init"></a>

Depois de concluir os [Conceitos básicos](serverless-getting-started.md) e ler [Como usar AWS Serverless Application Model (AWS SAM)](chapter-using-sam.md), tudo estará pronto para criar um projeto do AWS SAM no seu ambiente de desenvolvedor. Seu AWS SAM projeto servirá como ponto de partida para escrever seu aplicativo sem servidor. Para obter uma lista de opções de AWS SAMCLI `sam init` comando, consulte[sam init](sam-cli-command-reference-sam-init.md).

O AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam init` fornece opções para inicializar um novo aplicativo sem servidor que consiste em:
+ Um AWS SAM modelo para definir seu código de infraestrutura.
+ Uma estrutura de pastas que organiza seu aplicativo.
+ Configuração para suas AWS Lambda funções.

Para criar um AWS SAM projeto, consulte os tópicos desta seção.

**nota**  
`sam init`inclui modelos de projeto para funções duráveis em tempos de execução compatíveis (TypeScript, Python, Java). Esses modelos fornecem código inicial e configuração para criar aplicativos sem servidor com estado.

**Topics**
+ [

## Inicialize um novo aplicativo com tecnologia sem servidor.
](#using-sam-cli-init-new)
+ [

## Opções para o sam init
](#using-sam-cli-init-options)
+ [

## Solução de problemas
](#using-sam-cli-init-troubleshooting)
+ [

## Exemplos
](#using-sam-cli-init-examples)
+ [

## Saiba mais
](#using-sam-cli-init-learn)
+ [

## Próximas etapas
](#w2aac18c11c39)

## Inicialize um novo aplicativo com tecnologia sem servidor.
<a name="using-sam-cli-init-new"></a>

**Para inicializar um novo aplicativo com tecnologia sem servidor usando o AWS SAM CLI**

1. `cd` para um diretório inicial.

1. Execute o seguinte na linha de comando:

   ```
   $ sam init
   ```

1. O AWS SAMCLI o guiará por um fluxo interativo para criar um novo aplicativo com tecnologia sem servidor.
**nota**  
Conforme detalhado em [Tutorial: implante um aplicativo Hello World com AWS SAM](serverless-getting-started-hello-world.md), esse comando inicializa a aplicação sem servidor, criando o diretório do projeto. Esse diretório conterá vários arquivos e pastas. O arquivo mais importante é `template.yaml`. Esse é o seu AWS SAM modelo. A versão do python deve corresponder à versão do python listada no arquivo `template.yaml` criado pelo comando **sam init**.

### Escolha um modelo inicial
<a name="using-sam-cli-init-new-template"></a>

Um *modelo* consiste no seguinte:

1. Um AWS SAM modelo para seu código de infraestrutura.

1. Um diretório inicial do projeto que organiza seus arquivos de projeto. Por exemplo, isso pode incluir:

   1. Uma estrutura para o código de função do Lambda e suas dependências.

   1. Uma pasta `events` que contém eventos de teste para testes locais.

   1. Uma pasta `tests` para oferecer suporte ao teste de unidade.

   1. Um arquivo `samconfig.toml` para definir as configurações do projeto.

   1. Um arquivo `ReadMe` e outros arquivos básicos do projeto inicial.

   Veja a seguir um exemplo de um diretório de projeto inicial:

   ```
   sam-app
   ├── 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
   ```

Você pode selecionar em uma lista de *AWS modelos de início rápido* disponíveis ou fornecer sua própria *localização de modelo personalizado*.

**Para escolher um modelo de início AWS rápido**

1. Quando solicitado, selecione **AWS Modelos de início rápido**.

1. Selecione um modelo de Início AWS Rápido para começar. Este é um exemplo:

   ```
   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: 4
   ```

**Para escolher sua própria localização de modelo personalizado**

1. Quando solicitado, selecione a **localização do modelo personalizado**.

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

1. O AWS SAMCLI solicitará que você forneça uma localização do modelo.

   ```
   Template location (git, mercurial, http(s), zip, path):
   ```

   Forneça qualquer uma das seguintes localizações para o arquivo de arquivos.zip do modelo:
   + **GitHubrepositório** — O caminho para o arquivo.zip no seu repositório GitHub. O arquivo deve estar na raiz do seu repositório.
   + **Mercurialrepositório** — O caminho para o arquivo.zip no seu repositório Mercurial. O arquivo deve estar na raiz do seu repositório.
   + **caminho.zip** — Um caminho HTTPS ou localização para seu arquivo.zip.

1. O AWS SAMCLI inicializará seu aplicativo com tecnologia sem servidor usando seu modelo personalizado.

### Escolher um tempo de execução
<a name="using-sam-cli-init-new-runtime"></a>

Quando você escolhe um *AWS Modelo de início rápido*, o AWS SAMCLI solicitará que você selecione um tempo de execução para suas funções do Lambda. A lista de opções exibida pelo AWS SAMCLI são os tempos de execução suportados nativamente pelo Lambda.
+ O [tempo de execução](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-runtime) fornece um ambiente específico de linguagem que é executado no ambiente de execução.
+ [Quando implantado no Nuvem AWS, o serviço Lambda invoca sua função em um ambiente de execução.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html)

Você pode usar qualquer outra linguagem de programação com um tempo de execução personalizado. Para fazer isso, você precisa criar manualmente a estrutura inicial do aplicativo. Em seguida, você pode usar o `sam init` para inicializar rapidamente seu aplicativo configurando uma localização de modelo personalizado.

A partir da sua seleção, o AWS SAMCLI cria o diretório inicial para o código e as dependências da função do Lambda.

Se o Lambda oferecer suporte a vários gerenciadores de dependências para seu tempo de execução, você será solicitado a escolher seu gerenciador de dependências preferido.

### Escolha um tipo de pacote
<a name="using-sam-cli-init-new-package"></a>

Quando você escolhe um *AWS modelo de início rápido* e um *tempo de execução*, o AWS SAMCLI solicita que você selecione um *tipo de pacote*. O tipo de pacote determina como suas funções do Lambda são implantadas para uso com o serviço Lambda. Os dois tipos de pacotes compatíveis são:

1. **Imagem de contêiner** – Contém o sistema operacional de base, o tempo de execução, as extensões do Lambda, o código do seu aplicativo e suas dependências.

1. **arquivo .zip** – Contém o código do seu aplicativo e suas dependências.

Para saber mais sobre os tipos de pacotes de implantação, consulte [Pacotes de implantação do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) no *AWS Lambda Guia do desenvolvedor*.

Veja a seguir um exemplo de estrutura de diretórios de um aplicativo com uma função do Lambda empacotada como uma imagem de contêiner. O AWS SAMCLI baixa a imagem e cria um `Dockerfile` no diretório da função para especificar a imagem.

```
sam-app
├── README.md
├── __init__.py
├── events
│   └── event.json
├── hello_world
│   ├── Dockerfile
│   ├── __init__.py
│   ├── app.py
│   └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
    ├── __init__.py
    └── unit
        ├── __init__.py
        └── test_handler.py
```

A seguir está um exemplo de estrutura do diretório de um aplicativo com uma função empacotada como um arquivo .zip.

```
sam-app
├── 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
```

### Configurar o AWS X-Ray rastreamento
<a name="using-sam-cli-init-new-tracing"></a>

Você pode optar por ativar o AWS X-Ray rastreamento. Para saber mais, consulte [O que é AWS X-Ray?](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) no *Guia do AWS X-Ray desenvolvedor*.

Se você ativar, ele AWS SAMCLI configura seu AWS SAM modelo. Este é um exemplo:

```
Globals:
  Function:
    ...
    Tracing: Active
  Api:
    TracingEnabled: True
```

### Configure o monitoramento com o Amazon CloudWatch Application Insights
<a name="using-sam-cli-init-new-insights"></a>

Você pode optar por ativar o monitoramento usando o Amazon CloudWatch Application Insights. Para saber mais, consulte [Amazon CloudWatch Application Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html) no *Guia CloudWatch do usuário da Amazon*.

Se você ativar, ele AWS SAMCLI configura seu AWS SAM modelo. Este é um exemplo:

```
Resources:
  ApplicationResourceGroup:
    Type: AWS::ResourceGroups::Group
    Properties:
      Name:
        Fn::Join:
        - ''
        - - ApplicationInsights-SAM-
          - Ref: AWS::StackName
      ResourceQuery:
        Type: CLOUDFORMATION_STACK_1_0
  ApplicationInsightsMonitoring:
    Type: AWS::ApplicationInsights::Application
    Properties:
      ResourceGroupName:
        Fn::Join:
        - ''
        - - ApplicationInsights-SAM-
          - Ref: AWS::StackName
      AutoConfigurationEnabled: 'true'
    DependsOn: ApplicationResourceGroup
```

### Dê um nome para o seu aplicativo
<a name="using-sam-cli-init-new-name"></a>

Forneça um nome para seu aplicativo. O AWS SAMCLI cria uma pasta de nível superior para seu aplicativo usando esse nome.

## Opções para o sam init
<a name="using-sam-cli-init-options"></a>

Veja a seguir algumas das opções principais que você pode usar com o comando `sam init`. Para obter uma lista de todas as opções, consulte [sam init](sam-cli-command-reference-sam-init.md).

### Inicializar um aplicativo usando um local de modelo personalizado
<a name="using-sam-cli-init-options-location"></a>

Use a opção `--location` e forneça um local de modelo personalizado compatível. Veja um exemplo a seguir.

```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```

### Inicializar um aplicativo sem o fluxo interativo
<a name="using-sam-cli-init-options-no-interactive"></a>

Use a opção `--no-interactive` e forneça suas opções de configuração na linha de comando para ignorar o fluxo interativo. Veja um exemplo a seguir.

```
$ sam init --no-interactive --runtime go1.x --name go-demo --dependency-manager mod --app-template hello-world
```

## Solução de problemas
<a name="using-sam-cli-init-troubleshooting"></a>

Para solucionar o problema do AWS SAMCLI, consulte[AWS SAM CLI solução de problemas](sam-cli-troubleshooting.md).

## Exemplos
<a name="using-sam-cli-init-examples"></a>

### Inicialize um novo aplicativo sem servidor usando o Hello World Starter Template AWS
<a name="using-sam-cli-init-examples-helloworld"></a>

Para este exemplo, consulte [Etapa 1: Inicialize o aplicativo de amostra Hello World](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-init) no *Tutorial: Implantação de um aplicativo Hello World*.

### Inicialize um novo aplicativo com tecnologia sem servidor com um local de modelo personalizado
<a name="using-sam-cli-init-examples-custom"></a>

Veja a seguir exemplos de como fornecer uma localização GitHub para seu modelo personalizado:

```
$ sam init --location gh:aws-samples/cookiecutter-aws-sam-python
$ sam init --location git+sh://git@github.com/aws-samples/cookiecutter-aws-sam-python.git
$ sam init --location hg+ssh://hg@bitbucket.org/repo/template-name
```

Veja a seguir um exemplo de caminho de arquivo local:

```
$ sam init --location /path/to/template.zip
```

Veja a seguir um exemplo de um caminho acessível por HTTPS:

```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```

## Saiba mais
<a name="using-sam-cli-init-learn"></a>

Para obter mais informações sobre como usar o comando`sam init`, consulte:
+ **[Aprendizagem AWS SAM: sam init](https://www.youtube.com/watch?v=9m3R-leD5Xo)** — série Serverless Land “Aprendizagem AWS SAM” sobre. YouTube
+ **[Estruturação de aplicativos com tecnologia sem servidor para uso com o AWS SAMCLI (Sessões com SAM S2E7)](https://www.youtube.com/watch?v=k9IRdgze9fQ)** — Sessões com séries AWS SAM no YouTube.

## Próximas etapas
<a name="w2aac18c11c39"></a>

Agora que você criou seu AWS SAM projeto, você está pronto para começar a criar seu aplicativo. Consulte [Defina sua infraestrutura com AWS SAM](serverless-authoring.md) para obter instruções detalhadas sobre as tarefas que você precisa concluir para fazer isso.