¿Cómo funciona AWS SAM

AWS SAM consta de dos componentes principales que se utilizan para crear la aplicación sin servidor:

Para expresar los recursos, las asignaciones de fuentes de eventos y otras propiedades que definen una aplicación sin servidor, defina los recursos y desarrolle la aplicación en la AWS SAM plantilla y en otros archivos del proyecto. AWS SAM Los usa AWS SAMCLI para ejecutar los comandos en su AWS SAM proyecto, que es la forma de inicializar, compilar, probar e implementar su aplicación sin servidor.

¿Cuál es la especificación AWS SAM de la plantilla?

La especificación AWS SAM de la plantilla es un marco de código abierto que puede utilizar para definir y administrar el código de infraestructura de aplicaciones sin servidor. La especificación de la AWS SAM plantilla es:

¿Qué son el AWS SAM proyecto y la AWS SAM plantilla?

El AWS SAM proyecto incluye la AWS SAM plantilla que contiene la especificación AWS SAM de la plantilla. Esta especificación es el marco de código abierto que se utiliza para definir la infraestructura de aplicaciones sin servidor AWS, con algunos componentes adicionales que facilitan el trabajo con ellos. En este sentido, AWS SAM las plantillas son una extensión de AWS CloudFormation las plantillas.

A continuación se muestra un ejemplo de una aplicación sin servidor básica. Esta aplicación procesa las solicitudes para obtener todos los elementos de una base de datos mediante una HTTP solicitud. Consta de los elementos siguientes:

El código de infraestructura de esta aplicación se puede definir en la siguiente plantilla de 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: nodejs12.x
      Events:
        Api:
          Type: HttpApi
          Properties:
            Path: /
            Method: GET
    Connectors:
      MyConn:
        Properties:
          Destination:
            Id: SampleTable
          Permissions:
            - Read
  SampleTable:
    Type: AWS::Serverless::SimpleTable

En 23 líneas de código, se define la siguiente infraestructura:

Para aprovisionar esta infraestructura, la plantilla se implementa en AWS CloudFormation. Durante la implementación, AWS SAM transforma las 23 líneas de código en la AWS CloudFormation sintaxis necesaria para generar estos recursos AWS. ¡La AWS CloudFormation plantilla transformada contiene más de 200 líneas de código!

{
  "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"
          }
        ]
      }
    }
  }
}

Al AWS SAM utilizarla, se definen 23 líneas de código de infraestructura. AWS SAM transforma el código en las más de 200 líneas de AWS CloudFormation código necesarias para aprovisionar la aplicación.

¿Qué es el? AWS SAMCLI

AWS SAMCLISe trata de una herramienta de línea de comandos que puede utilizar con AWS SAM plantillas e integraciones de terceros compatibles para crear y ejecutar sus aplicaciones sin servidor. Use la CLI de AWS SAM para:

Se AWS SAMCLI utiliza mejor cuando se utiliza con plantillas AWS SAM y AWS CloudFormation . También funciona con productos de terceros, como Terraform.

Inicio de un nuevo proyecto

Seleccione una de las plantillas iniciales o elija una ubicación de plantilla personalizada para comenzar un nuevo proyecto.

A continuación se muestra el comando sam init para iniciar un nuevo proyecto de aplicación. Para empezar, seleccionamos el proyecto Hello World Example. La CLI de AWS SAM descarga una plantilla inicial y crea la estructura de directorios de carpetas del proyecto.

Para obtener más información, consulte Crea tu aplicación en AWS SAM.

Compilación de su aplicación para implementación

Empaquete las dependencias de sus funciones y organice el código del proyecto y la estructura de carpetas para prepararlos para la implementación.

En este caso, utilizamos el comando sam build para preparar nuestra aplicación para su implementación. La CLI de AWS SAM crea un directorio .aws-sam y organiza allí las dependencias y los archivos de nuestras aplicaciones para su implementación.

Para obtener más información, consulte Cree su aplicación.

Realización de pruebas y depuraciones locales

En su máquina local, simule eventos, pruebeAPIs, invoque funciones y mucho más para depurar y probar su aplicación.

En este caso, utilizamos el comando sam local invoke para invocar HelloWorldFunction de forma local. Para ello, la CLI de AWS SAM crea un contenedor local, crea nuestra función, la invoca y genera los resultados. Puede usar una aplicación como Docker para ejecutar contenedores en su máquina.

Para obtener más información, consultePruebe su aplicación y Depure su aplicación.

Implementar la aplicación

Configure los ajustes de despliegue de su aplicación e impleméntela AWS en la nube para aprovisionar sus recursos.

Aquí, utilizamos el comando sam deploy --guided para implementar nuestra aplicación a través de un flujo interactivo. Esto nos AWS SAMCLI guía a través de la configuración de los ajustes de despliegue de nuestra aplicación AWS CloudFormation, transforma nuestra plantilla en ella y la implementa AWS CloudFormation para crear nuestros recursos.

Para obtener más información, consulte Implemente su aplicación y sus recursos.

Configuración de las canalizaciones de implementación de CI/CD

Cree canalizaciones seguras de integración y entrega continuas (CI/CD) mediante un sistema de CI/CD compatible.

En este caso, utilizamos el comando sam pipeline init --bootstrap para configurar una canalización de implementación de CI/CD para nuestra aplicación. Nos AWS SAMCLI guía a través de nuestras opciones y genera AWS los recursos y el archivo de configuración para usarlos con nuestro sistema de CI/CD.

Para obtener más información, consulte Implemente con sistemas y canalizaciones de CI/CD.

Supervisión y solución de los problemas de la aplicación en la nube

Consulte información importante sobre los recursos desplegados, recopile registros y utilice herramientas de supervisión integradas, como AWS X-Ray.

En este caso, utilizamos el comando sam list para ver los recursos desplegados. Obtenemos nuestro API punto final y lo invocamos, lo que activa nuestra función. Luego, usamos sam logs para ver los registros de la función.

Para obtener más información, consulte Supervise su aplicación.

Sincronización de los cambios locales con la nube a medida que vaya desarrollando

A medida que vaya desarrollando en su máquina local, sincronice automáticamente los cambios con la nube. Consulte rápidamente los cambios y realice pruebas y validaciones en la nube.

En este caso, utilizaremos el comando sam sync --watch para que la CLI de AWS SAM vigile los cambios locales. Modificaremos el código HelloWorldFunction y, de forma automática, la CLI de AWS SAM detectará el cambio e implementará las actualizaciones en la nube.

Prueba de los recursos compatibles en la nube

Invoque y transfiera eventos a los recursos compatibles en la nube.

En este caso, utilizamos el comando sam remote invoke para probar una función de Lambda implementada en la nube. Invocamos la función de Lambda y recibimos sus registros y su respuesta. Con la función de Lambda configurada para transmitir las respuestas, la CLI de AWS SAM transmite su respuesta en tiempo real.

Más información

Para seguir informándote AWS SAM, consulta los siguientes recursos:

Siguientes pasos

Si es la primera vez que lo usa AWS SAM, consulte. Empezar con AWS SAM