Como o AWS SAM funciona

O AWS SAM consiste em dois componentes principais que você usa para criar a aplicação sem servidor:

1. O projeto do AWS SAM: as pastas e os arquivos criados quando você executa o comando sam init. Esse diretório inclui o modelo do AWS SAM, um arquivo importante que define os recursos da AWS. Esse modelo inclui a especificação do modelo do AWS SAM: a estrutura de código aberto que vem com uma sintaxe abreviada simplificada que você usa para definir as funções, os eventos, as APIs, as configurações e as permissões da aplicação sem servidor.

2. A ação AWS SAMCLI: uma ferramenta de linha de comando que você pode usar com o projeto do AWS SAM e com integrações de terceiros compatíveis para criar e executar aplicações sem servidor. A CLI do AWS SAM é a ferramenta que você usa para executar comandos no projeto do AWS SAM e, por fim, transformá-lo na aplicação sem servidor.

Para expressar recursos, mapeamentos da origem do evento e outras propriedades que definem a aplicação sem servidor, defina recursos e desenvolva a aplicação no modelo do AWS SAM e em outros arquivos do projeto do AWS SAM. Use a CLI do AWS SAM para executar comandos no projeto do AWS SAM, que é como você inicializa, cria, testa e implanta a aplicação sem servidor.

Está começando na tecnologia sem servidor?

Recomendamos que você analise Conceitos de tecnologia sem servidor para o AWS Serverless Application Model.

Qual é a especificação do modelo AWS SAM?

A especificação do modelo AWS SAM é uma estrutura de código aberto que você pode usar para definir e gerenciar seu código de infraestrutura de aplicação com tecnologia sem servidor. A especificação do modelo AWS SAM é:

• Criado no AWS CloudFormation: use a sintaxe do AWS CloudFormation diretamente no modelo do AWS SAM, aproveitando seu amplo suporte para configurações de recursos e propriedades. Se você já está familiarizado com AWS CloudFormation, não precisa aprender um novo serviço para gerenciar seu código de infraestrutura de aplicativos.

• Uma extensão de AWS CloudFormation – AWS SAM oferece sua própria sintaxe exclusiva que se concentra especificamente em acelerar o desenvolvimento sem servidor. Você pode usar a sintaxe AWS CloudFormation AWS SAM e no mesmo modelo.

• Uma sintaxe abstrata e abreviada – Usando a AWS SAM sintaxe, você pode definir sua infraestrutura rapidamente, em menos linhas de código e com menor chance de erros. Sua sintaxe é especialmente selecionada para abstrair a complexidade na definição de sua infraestrutura de aplicativos sem servidor.

• Transformacional – AWS SAM faz o trabalho complexo de transformar seu modelo no código necessário para provisionar sua infraestrutura AWS CloudFormation.

O que são o projeto do AWS SAM e o modelo do AWS SAM?

O projeto do AWS SAM inclui o modelo do AWS SAM que contém a especificação do modelo do AWS SAM. Essa especificação é a estrutura de código aberto que você usa para definir a infraestrutura da aplicação sem servidor na AWS, com alguns componentes adicionais que facilitam o trabalho. Sendo assim, os modelos do AWS SAM são uma extensão dos modelos do AWS CloudFormation.

Veja um exemplo de aplicação com tecnologia sem servidor básica. Esse aplicativo processa solicitações para obter todos os itens de um banco de dados por meio de uma solicitação HTTP. Isso consiste nas seguintes partes:

1. Uma função que contém a lógica para processar a solicitação.

2. Uma API HTTP para servir como comunicação entre o cliente (solicitante) e o aplicativo.

3. Um banco de dados para armazenar itens.

4. Permissões para que o aplicativo seja executado com segurança.

O código de infraestrutura desse aplicativo pode ser definido no seguinte modelo AWS SAM:

AWSTemplateFormatVersion: 2010-09-09
Transform: AWS::Serverless-2016-10-31
Resources:
  getAllItemsFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/get-all-items.getAllItemsHandler
      Runtime: nodejs20.x
      Events:
        Api:
          Type: HttpApi
          Properties:
            Path: /
            Method: GET
    Connectors:
      MyConn:
        Properties:
          Destination:
            Id: SampleTable
          Permissions:
            - Read
  SampleTable:
    Type: AWS::Serverless::SimpleTable

Em 23 linhas de código, a seguinte infraestrutura é definida:

• Uma função usando o serviço AWS Lambda.

• Uma API HTTP usando o serviço Amazon API Gateway.

• Um banco de dados usando o serviço Amazon DynamoDB.

• As permissões AWS Identity and Access Management (IAM) necessárias para que esses serviços interajam entre si.

Para provisionar essa infraestrutura, o modelo é implantado em AWS CloudFormation. Durante a implantação, AWS SAM transforma as 23 linhas de código na sintaxe AWS CloudFormation necessária para gerar esses recursos AWS. O modelo AWS CloudFormation transformado contém mais de 200 linhas de código!

Modelo AWS CloudFormation transformado

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Resources": {
    "getAllItemsFunction": {
      "Type": "AWS::Lambda::Function",
      "Metadata": {
        "SamResourceId": "getAllItemsFunction"
      },
      "Properties": {
        "Code": {
          "S3Bucket": "aws-sam-cli-managed-default-samclisourcebucket-1a4x26zbcdkqr",
          "S3Key": "what-is-app/a6f856abf1b2c4f7488c09b367540b5b"
        },
        "Handler": "src/get-all-items.getAllItemsHandler",
        "Role": {
          "Fn::GetAtt": [
            "getAllItemsFunctionRole",
            "Arn"
          ]
        },
        "Runtime": "nodejs12.x",
        "Tags": [
          {
            "Key": "lambda:createdBy",
            "Value": "SAM"
          }
        ]
      }
    },
    "getAllItemsFunctionRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Version": "2012-10-17",
          "Statement": [
            {
              "Action": [
                "sts:AssumeRole"
              ],
              "Effect": "Allow",
              "Principal": {
                "Service": [
                  "lambda.amazonaws.com"
                ]
              }
            }
          ]
        },
        "ManagedPolicyArns": [
          "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
        ],
        "Tags": [
          {
            "Key": "lambda:createdBy",
            "Value": "SAM"
          }
        ]
      }
    },
    "getAllItemsFunctionApiPermission": {
      "Type": "AWS::Lambda::Permission",
      "Properties": {
        "Action": "lambda:InvokeFunction",
        "FunctionName": {
          "Ref": "getAllItemsFunction"
        },
        "Principal": "apigateway.amazonaws.com",
        "SourceArn": {
          "Fn::Sub": [
            "arn:${AWS::Partition}:execute-api:${AWS::Region}:${AWS::AccountId}:${__ApiId__}/${__Stage__}/GET/",
            {
              "__ApiId__": {
                "Ref": "ServerlessHttpApi"
              },
              "__Stage__": "*"
            }
          ]
        }
      }
    },
    "ServerlessHttpApi": {
      "Type": "AWS::ApiGatewayV2::Api",
      "Properties": {
        "Body": {
          "info": {
            "version": "1.0",
            "title": {
              "Ref": "AWS::StackName"
            }
          },
          "paths": {
            "/": {
              "get": {
                "x-amazon-apigateway-integration": {
                  "httpMethod": "POST",
                  "type": "aws_proxy",
                  "uri": {
                    "Fn::Sub": "arn:${AWS::Partition}:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${getAllItemsFunction.Arn}/invocations"
                  },
                  "payloadFormatVersion": "2.0"
                },
                "responses": {}
              }
            }
          },
          "openapi": "3.0.1",
          "tags": [
            {
              "name": "httpapi:createdBy",
              "x-amazon-apigateway-tag-value": "SAM"
            }
          ]
        }
      }
    },
    "ServerlessHttpApiApiGatewayDefaultStage": {
      "Type": "AWS::ApiGatewayV2::Stage",
      "Properties": {
        "ApiId": {
          "Ref": "ServerlessHttpApi"
        },
        "StageName": "$default",
        "Tags": {
          "httpapi:createdBy": "SAM"
        },
        "AutoDeploy": true
      }
    },
    "SampleTable": {
      "Type": "AWS::DynamoDB::Table",
      "Metadata": {
        "SamResourceId": "SampleTable"
      },
      "Properties": {
        "AttributeDefinitions": [
          {
            "AttributeName": "id",
            "AttributeType": "S"
          }
        ],
        "KeySchema": [
          {
            "AttributeName": "id",
            "KeyType": "HASH"
          }
        ],
        "BillingMode": "PAY_PER_REQUEST"
      }
    },
    "getAllItemsFunctionMyConnPolicy": {
      "Type": "AWS::IAM::ManagedPolicy",
      "Metadata": {
        "aws:sam:connectors": {
          "getAllItemsFunctionMyConn": {
            "Source": {
              "Type": "AWS::Serverless::Function"
            },
            "Destination": {
              "Type": "AWS::Serverless::SimpleTable"
            }
          }
        }
      },
      "Properties": {
        "PolicyDocument": {
          "Version": "2012-10-17",
          "Statement": [
            {
              "Effect": "Allow",
              "Action": [
                "dynamodb:GetItem",
                "dynamodb:Query",
                "dynamodb:Scan",
                "dynamodb:BatchGetItem",
                "dynamodb:ConditionCheckItem",
                "dynamodb:PartiQLSelect"
              ],
              "Resource": [
                {
                  "Fn::GetAtt": [
                    "SampleTable",
                    "Arn"
                  ]
                },
                {
                  "Fn::Sub": [
                    "${DestinationArn}/index/*",
                    {
                      "DestinationArn": {
                        "Fn::GetAtt": [
                          "SampleTable",
                          "Arn"
                        ]
                      }
                    }
                  ]
                }
              ]
            }
          ]
        },
        "Roles": [
          {
            "Ref": "getAllItemsFunctionRole"
          }
        ]
      }
    }
  }
}

Ao usar AWS SAM, você define 23 linhas de código de infraestrutura. AWS SAM transforma seu código nas mais de 200 linhas de código de AWS CloudFormation necessárias para provisionar seu aplicativo.

O que é o CLI do AWS SAM?

O AWS SAM CLI é uma ferramenta de linha de comando que você pode usar com AWS SAM modelos e integrações de terceiros compatíveis para criar e executar seus aplicativos sem servidor. Use o AWS SAM CLI para:

• Inicialize rapidamente um projeto de aplicação.

• Crie seu aplicativo para implantação.

• Execute depuração e testes locais.

• Implante o aplicativo.

• Configure pipelines de implantação de CI/CD.

• Monitore e solucione problemas de seu aplicativo na nuvem.

• Sincronize as alterações locais com a nuvem à medida que você se desenvolve.

• E muito mais!

O AWS SAM CLI é melhor utilizado quando usado com modelos AWS SAM e AWS CloudFormation. Também funciona com produtos de terceiros, como Terraform.

Inicialize um projeto

Selecione um dos modelos iniciais ou escolha um local de modelo personalizado para começar um novo projeto.

Aqui, usamos o comando sam init para inicializar um projeto de aplicação. Selecionamos o projeto Hello World Example para começar. O AWS SAM CLI baixa um modelo inicial e cria nossa estrutura de diretórios de pastas do projeto.

Para obter mais detalhes, consulte Criar aplicações no AWS SAM.

Crie seu aplicativo para implantação

Empacote suas dependências de função e organize o código do projeto e a estrutura de pastas para se preparar para a implantação.

Aqui, usamos o comando sam build para preparar nosso aplicativo para implantação. O AWS SAM CLI cria um diretório .aws-sam e organiza as dependências e os arquivos do nosso aplicativo para implantação.

Para obter mais detalhes, consulte Criar aplicações.

Execute depuração e testes locais

Em sua máquina local, simule eventos, teste APIs, invoque funções e muito mais para depurar e testar seu aplicativo.

Aqui, usamos o comando sam local invoke para invocar nosso HelloWorldFunction localmente. Para fazer isso, o AWS SAM CLI cria um contêiner local, constrói nossa função, a invoca e gera os resultados. Você pode usar uma aplicação, como o Docker, para executar contêineres no seu computador.

Para obter mais detalhes, consulte Testar a aplicação e Depurar a aplicação.

Implantar o aplicativo

Defina as configurações de implantação do seu aplicativo e implante na nuvem AWS para provisionar seus recursos.

Aqui, usamos o comando sam deploy --guided para implantar nosso aplicativo por meio de um fluxo interativo. O AWS SAM CLI nos orienta na configuração das configurações de implantação de nosso aplicativo, transforma nosso modelo em AWS CloudFormation e implanta AWS CloudFormation para criar nossos recursos.

Para obter mais detalhes, consulte Implantar a aplicação e os recursos.

Configure pipelines de implantação de CI/CD

Crie pipelines seguros de integração e entrega contínuas (CI/CD), usando um sistema de CI/CD compatível.

Aqui, usamos o comando sam pipeline init --bootstrap para configurar um pipeline de implantação de CI/CD para nosso aplicativo. O AWS SAM CLI nos guia por nossas opções e gera o recursos AWS e o arquivo de configuração para usar com nosso sistema CI/CD.

Para obter mais detalhes, consulte Implantar com sistemas e pipelines CI/CD.

Monitore e solucione problemas de seu aplicativo na nuvem

Visualize informações importantes sobre seus recursos implantados, colete registros e utilize ferramentas de monitoramento integradas, como AWS X-Ray.

Aqui, usamos o comando sam list para visualizar nossos recursos implantados. Pegamos nosso endpoint de API e o invocamos, o que aciona nossa função. Em seguida, usamos sam logs para visualizar os registros da nossa função.

Para obter mais detalhes, consulte Monitorar a aplicação.

Sincronize as alterações locais com a nuvem à medida que você se desenvolve

Conforme você desenvolve em sua máquina local, sincronize automaticamente as alterações na nuvem. Veja rapidamente suas alterações e realize testes e validação na nuvem.

Aqui, usamos o comando sam sync --watch para AWS SAM CLI observar as mudanças locais. Modificamos nosso código HelloWorldFunction, detectamos AWS SAM CLI automaticamente a alteração e implantamos nossas atualizações na nuvem.

Testes os recursos com suporte na nuvem

Invoque e transmita eventos para recursos compatíveis na nuvem.

Aqui, usamos o comando sam remote invoke para testar uma função do Lambda implantada na nuvem. Invocamos nossa função do Lambda e recebemos seus registros e respostas. Com nossa função do Lambda configurada para transmitir respostas, AWS SAM CLI retransmite sua resposta em tempo real.

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.

Próximas etapas

Se esta é a primeira vez que você usa AWS SAM, consulte Conceitos básicos do AWS SAM.