Como AWS SAM funciona

Ao trabalhar com AWS SAM a criação de seu aplicativo sem servidor, você interagirá com os seguintes componentes:

Para expressar recursos, mapeamentos de origem de eventos e outras propriedades que definem seu aplicativo sem servidor, você define recursos e desenvolve seu aplicativo no AWS SAM modelo e em outros arquivos do seu projeto. AWS SAM Você usa o AWS SAMCLI para executar comandos em seu AWS SAM projeto, que é como você inicializa, cria, testa e implanta seu aplicativo sem servidor.

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

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

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

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

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:

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:

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

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Resources": {
    "getAllItemsFunction": {
      "Type": "AWS::Lambda::Function",
      "Metadata": {
        "SamResourceId": "getAllItemsFunction"
      },
      "Properties": {
        "Code": {
          "S3Bucket": "amzn-s3-demo-source-bucket-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 AWS CloudFormation código necessárias para provisionar seu aplicativo.

O que é o AWS SAMCLI?

AWS SAMCLIÉ 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 SAMCLI para:

O AWS SAMCLI é melhor utilizado quando usado com AWS SAM AWS CloudFormation modelos. 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 SAMCLI baixa um modelo inicial e cria nossa estrutura de diretórios de pastas do projeto.

Consulte mais detalhes em Crie seu aplicativo em 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 SAMCLI cria um diretório .aws-sam e organiza as dependências e os arquivos do nosso aplicativo para implantação.

Consulte mais detalhes em 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 SAMCLI 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 AWS nuvem para provisionar seus recursos.

Aqui, usamos o comando sam deploy --guided para implantar nosso aplicativo por meio de um fluxo interativo. Ele nos AWS SAMCLI 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.

Consulte mais detalhes em Implantar a aplicação e os recursos.

Configurar pipelines CI/CD de implantação

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

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

Consulte mais detalhes em Implemente com CI/CD sistemas e pipelines.

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.

Consulte mais detalhes em 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 SAMCLI observar as mudanças locais. Modificamos nosso código HelloWorldFunction, detectamos AWS SAMCLI 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 SAMCLI retransmite sua resposta em tempo real.

Saiba mais

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

Próximas etapas

Se esta é a primeira vez que você usa AWS SAM, consulteComeçando com AWS SAM.