Execute `serverless` para verificar se a sua instalação está funcionando e mostrar a versão atual.

<br/>

## Atualizar o Serverless Framework

A partir da versão 4, o Serverless Framework se atualiza automaticamente e realiza uma verificação para isso a cada 24 horas.

Você pode forçar uma atualização executando este comando:```text
serverless update

<br/>

## O Comando `serverless`

O Serverless Framework vem com um comando `serverless` que o guia na criação e implantação de um projeto na AWS. Ele ajuda a baixar um Template, configurar as Credenciais AWS, configurar o Painel do Serverless Framework e muito mais, explicando cada conceito ao longo do caminho.

Este guia também o orientará nos primeiros passos com o Serverless Framework, mas lembre-se: simplesmente digitar o comando `serverless` pode ser a experiência superior.```text
serverless

Isto mostrará vários Modelos. Escolha um que se ajuste ao idioma e ao caso de uso que deseja.```text
Serverless ϟ Framework
Welcome to Serverless Framework V.4

Create a new project by selecting a Template to generate scaffolding for a specific use-case.

? Select A Template: …
❯ AWS / Node.js / HTTP API
  AWS / Node.js / Express API
  AWS / Node.js / Express API with DynamoDB
  AWS / Node.js / Scheduled Task
  AWS / Node.js / Simple Function
  AWS / Python / HTTP API
  AWS / Python / Flask API
  AWS / Python / Flask API with DynamoDB
  AWS / Python / Scheduled Task
  AWS / Python / Simple Function
  (Scroll for more)

Use apenas letras minúsculas, números e hífens. Além disso, mantenha os nomes dos Serviços curtos, pois eles são adicionados ao nome de cada recurso de nuvem que o Serverless Framework cria, e alguns recursos de nuvem têm restrições de comprimento de caracteres em seus nomes.

Saiba mais sobre Serviços e muito mais na [documentação de Conceitos Principais](https://www.serverless.com/framework/docs/providers/aws/guide/intro).

<br/>

## Entrando

A partir do Serverless Framework V.4, se você estiver usando o comando `serverless` para configurar um Serviço, ele acabará pedindo que você faça login.

Se você precisar fazer login fora disso, execute `serverless login`.

Fazer login redirecionará você para o [Painel do Serverless Framework](https://app.serverless.com) no seu navegador. Após se registrar ou fazer login, volte para o seu CLI e você estará conectado.

Observe que você pode começar a usar o CLI do Serverless Framework e o Painel gratuitamente, e o CLI sempre será gratuito para pequenas organizações e indie hackers. Para mais informações sobre preços, consulte nossa [página de preços](https://serverless.com/pricing).

<br/>

## Criando um App

O conceito de "App" é um contêiner pai para um ou muitos "Serviços" que você pode opcionalmente definir por meio da propriedade `app` no seu `serverless.yml`. Definir um `app` também habilita os recursos do Painel do Serverless Framework para esse Serviço, como rastrear seus Serviços e suas implantações no Painel do Serverless Framework, permitir o compartilhamento de saídas entre eles, compartilhar segredos entre eles e habilitar métricas, rastreamentos e logs.

Se você estiver usando o comando `serverless` de integração, ele ajudará você a configurar um `app` e adicioná-lo ao seu Serviço. Você também pode usar o comando `serverless` para criar um App em um Serviço existente, ou criar um App no Painel.```text
❯ Create A New App
  ecommerce
  blog
  acmeinc
  Skip Adding An App

Se você não quiser usar os recursos do Serverless Framework Dashboard, basta não adicionar uma propriedade `app`. Os apps não são obrigatórios.

<br/>

## Configurando as credenciais da AWS

Para implantar infraestrutura de nuvem na AWS, você deve dar ao Serverless Framework acesso às suas credenciais da AWS.

Executar o comando `serverless` do Serverless Framework em um Service novo ou existente ajudará a identificar se as credenciais da AWS foram configuradas corretamente ou se expiraram, ou ajudará você a configurá-las do zero.```text
No valid AWS Credentials were found in your environment variables or on your machine. Serverless Framework needs these to access your AWS account and deploy resources to it. Choose an option below to set up AWS Credentials.

❯ Create AWS IAM Role (Easy & Recommended)
  Save AWS Credentials in a Local Profile
  Skip & Set Later (AWS SSO, ENV Vars)

A implantação criará/atualizará a infraestrutura de nuvem e o código na AWS, tudo ao mesmo tempo.

Execute o comando `deploy`:```text
serverless deploy

Quando você executa este comando, o seguinte acontece...

Uma implantação AWS Cloudformation será executada para modificar ligeiramente todas as funções AWS Lambda dentro do seu serviço, de modo que elas incluam um wrapper leve.

Assim que essa implantação AWS Cloudformation for concluída, suas funções AWS Lambda ativas dentro do seu serviço ainda poderão receber eventos e ser invocadas na AWS.

No entanto, os eventos serão encaminhados com segurança e instantaneamente via proxy para sua máquina, e é o código na sua máquina que será executado, em vez do código dentro das suas funções AWS Lambda ativas.

Isso permite que você faça alterações no seu código sem precisar implantar ou recriar todos os aspectos da sua arquitetura localmente, permitindo que você desenvolva rapidamente.

Os logs do seu código local também serão exibidos na sua sessão `dev` do terminal.

Quando o seu código terminar, a resposta do seu código local será encaminhada de volta para suas funções AWS Lambda ativas, e elas retornarão a resposta—exatamente como uma função AWS Lambda normal na nuvem faria.

Observe que o `dev` foi projetado apenas para desenvolvimento ou estágios/ambientes pessoais e não deve ser executado em produção ou em qualquer estágio onde um alto volume de eventos esteja sendo processado.

Quando terminar sua sessão `dev`, você DEVE reimplantar, usando `serverless deploy` para enviar suas alterações locais recentes de volta às suas funções AWS Lambda ativas—ou suas funções AWS Lambda falharão(!)

Mais detalhes sobre o modo dev podem ser encontrados [aqui](https://www.serverless.com/framework/docs/providers/aws/cli-reference/dev).

<br/>

## Invocação

Para invocar sua função AWS Lambda na nuvem, você pode encontrar as URLs das suas funções com endpoints de API na saída do `serverless deploy`, ou recuperá-las via `serverless info`. Se suas funções não tiverem endpoints de API, você pode usar o comando `invoke`, assim:

sls invoke -f hello

# Invoke and display logs:
serverless invoke -f hello --log
```
Mais detalhes sobre o comando `invoke` podem ser encontrados [aqui](https://www.serverless.com/framework/docs/providers/aws/cli-reference/invoke).

<br/>

## Implantar Funções

Para implantar alterações de código rapidamente, você pode pular o comando `serverless deploy`, que é muito mais lento, pois aciona uma atualização completa do AWS CloudFormation, e implantar apenas alterações de código e configuração em uma função AWS Lambda específica.

Para implantar alterações de código e configuração em funções AWS Lambda individuais em segundos, use o comando `deploy function`, com `-f [function name in serverless.yml]` definido para a função que você deseja implantar.```text
serverless deploy function -f my-api
```
Mais detalhes sobre o comando `deploy function` podem ser encontrados [aqui](https://www.serverless.com/framework/docs/providers/aws/cli-reference/deploy-function).

<br/>

## Streaming de Logs

Você pode usar o Serverless Framework para transmitir logs do AWS Cloudwatch diretamente para o seu terminal. Use o comando `sls logs` em uma janela de terminal separada:```bash
sls logs -f [Function name in serverless.yml] -t
```
Direcione uma função específica por meio da opção `-f` e ative o tailing (ou seja, o streaming) por meio da opção `-t`.

<br/>

## Desenvolvimento Local Completo

Muitos usuários do Serverless Framework optam por emular toda a sua arquitetura serverless localmente. Observe que emular AWS Lambda e outros serviços de nuvem nunca é preciso e o processo pode ser complexo, especialmente à medida que seu projeto e seus colegas de equipe crescem. A partir da V.4, recomendamos fortemente o uso do novo modo `dev` com stages pessoais.

Se você optar por desenvolver localmente, recomendamos o seguinte fluxo de trabalho...

Use o comando `invoke local` para invocar sua função localmente:```bash
sls invoke local -f my-api
```
Você também pode passar dados para esta invocação local de várias maneiras. Aqui está uma delas:```bash
sls invoke local --function functionName --data '{"a":"bar"}'
```
Mais detalhes sobre o comando `invoke local` podem ser encontrados [aqui](https://www.serverless.com/framework/docs/providers/aws/cli-reference/invoke-local)

O Serverless Framework também possui um ótimo plugin que permite executar um servidor localmente e emular o AWS API Gateway. Este é o plugin `serverless-offline`.

Mais detalhes podem ser encontrados na [documentação do serverless-offline](https://github.com/dherault/serverless-offline).

<br/>

## Usar Plugins

Um grande benefício do Serverless Framework está no seu [ecossistema de plugins](https://serverless.com/plugins).

Os plugins estendem ou sobrescrevem o Serverless Framework, dando a ele novos casos de uso ou capacidades, e existem centenas deles.

Observe que alguns plugins que eram populares antigamente não são mais necessários — a funcionalidade deles agora está incorporada ao framework, incluindo Python requirements, custom domains, AppSync, Prune e API Gateway Service Proxy.

Alguns dos plugins mais comuns são:

- **[Serverless Offline](https://github.com/dherault/serverless-offline)** - Emula AWS Lambda e API Gateway localmente ao desenvolver seu projeto Serverless.
- **[Serverless Step Functions](https://github.com/serverless-operations/serverless-step-functions)** - Construa arquiteturas AWS Step Functions.

Você pode adicionar um plugin ao seu serviço com [`serverless plugin install --name pluginName`](https://www.serverless.com/framework/docs/providers/aws/cli-reference/plugin-install), que o instala via npm e o registra no seu `serverless.yml`.

<br/>

## Composição de Serviços

O Serverless Framework Compose permite que você trabalhe com vários Serviços do Serverless Framework ao mesmo tempo e faça o seguinte...

- Implante vários serviços em paralelo
- Implante serviços em uma ordem específica
- Compartilhe saídas de um serviço com outro
- Execute comandos em vários serviços

Veja como uma estrutura de projeto pode se parecer:```bash
my-app/
  service-a/
    src/
      ...
    serverless.yml
  service-b/
    src/
      ...
    serverless.yml
```
O uso do Serverless Framework Compose requer um arquivo `serverless-compose.yml`. Nele, você especifica quais Serviços deseja implantar. Você também pode compartilhar dados de um Serviço para outro, o que também cria uma ordem de implantação.```yaml
# serverless-compose.yml

services:
  service-a:
    path: service-a

  service-b:
    path: service-b
    params:
      queueUrl: ${service-a.queueUrl}
```
As saídas a serem herdadas por outro Serviço são normalmente definidas como Outputs do AWS CloudFormation:```yaml
# service-a/serverless.yml

# ...

resources:
  Resources:
    MyQueue:
      Type: AWS::SQS::Queue
      # ...
  Outputs:
    queueUrl:
      Value: !Ref MyQueue
```
O valor será passado para `service-b` [como um parâmetro](https://www.serverless.com/framework/docs/guides/parameters) chamado `queueUrl`. Os parâmetros podem ser referenciados na configuração do Serverless Framework por meio da sintaxe `${param:xxx}`:```yaml
# service-b/serverless.yml

provider:
  ...
  environment:
    # Here we inject the queue URL as a Lambda environment variable
    SERVICE_A_QUEUE_URL: ${param:queueUrl}
```
Mais detalhes sobre o Serverless Framework Compose podem ser encontrados [aqui](https://www.serverless.com/framework/docs/guides/compose).

<br/>

## Comando de Suporte

No Serverless Framework V.4, introduzimos o comando `serverless support`, um recurso de destaque que permite gerar relatórios de problemas ou conectar-se diretamente à nossa equipe de suporte. Ele inclui automaticamente o contexto relevante e omite detalhes sensíveis, como segredos e informações de conta, que você pode verificar antes do envio. Esse processo simplificado garante que seus problemas sejam resolvidos de forma rápida e segura.

Para usar este recurso, após um erro ou qualquer comando, execute:```bash
sls support
```
Após cada comando, tenha ele sido bem-sucedido ou não, o contexto é salvo no seu diretório de trabalho atual na pasta `.serverless`.

Para abrir um novo ticket de suporte, execute o comando `sls support` e selecione `Get priority support...`. Opcionalmente, você poderá revisar e editar o relatório gerado. A abertura de tickets de suporte está disponível apenas para usuários que assinam uma Subscription.

Você também pode gerar relatórios sem enviar um novo ticket de suporte. Isso é útil para compartilhar contexto com outras pessoas, abrir issues no Github ou usá-lo com um prompt de IA como o ChatGPT. Para fazer isso, execute o comando `sls support` e selecione `Create a summary report...`, ou `Create a comprehensive report..`. Você pode pular o prompt executando `sls support --summary` ou `sls support --all`. Isso é especialmente útil para copiar o relatório para a área de transferência (por exemplo, `sls support --summary | pbcopy`).

<br/>

## Remova Seu Serviço

Se você quiser excluir seu serviço, execute `remove`. Isso excluirá todos os recursos da AWS criados pelo seu projeto e garantirá que você não tenha cobranças inesperadas. Também removerá o serviço do Serverless Dashboard.```bash
sls remove
```
Mais detalhes sobre o comando `remove` podem ser encontrados [aqui](https://www.serverless.com/framework/docs/providers/aws/cli-reference/remove).

<br/>

## Próximos Passos

Aqui estão alguns recursos úteis para continuar com o Serverless Framework:

- [Estude os conceitos principais do Serverless Framework](https://www.serverless.com/framework/docs/providers/aws/guide/intro)
- [Inspire-se com estes modelos do Serverless Framework](https://github.com/serverless/examples)
- [Descubra todos os eventos que podem acionar funções Lambda](https://www.serverless.com/framework/docs/providers/aws/guide/events)
- [Adicione aos favoritos o guia de `serverless.yml` do Serverless Framework](https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml)
- [Pesquise no registro de plugins para estender o Serverless Framework](https://www.serverless.com/plugins)

<br/>

# <a name="community"></a>Comunidade

- [X / Twitter](https://twitter.com/goserverless)
- [Slack da Comunidade](https://serverless.com/slack)
- [Meetups Serverless](http://www.meetup.com/serverless/)
- [Stackoverflow](http://stackoverflow.com/questions/tagged/serverless-framework)
- [Facebook](https://www.facebook.com/serverless)
- [Fale Conosco](mailto:[email protected])

## Segurança e Divulgação de Bugs

Levamos a segurança a sério. Se você descobrir um problema de segurança, divulgue-o de forma responsável entrando em contato conosco em [[email protected]](mailto:[email protected]). Não divulgue vulnerabilidades publicamente até que as tenhamos resolvido.

Para mais detalhes, consulte nossa [Política de Segurança](https://github.com/serverless/serverless/blob/main/SECURITY.md).