¿Cómo funciona AWS SAM

Cuando trabaje AWS SAM para crear su aplicación sin servidor, interactuará con los siguientes componentes:

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 de la AWS SAM 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 solicitud HTTP. 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: nodejs20.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": "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"
          }
        ]
      }
    }
  }
}

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 SAMCLIEs una herramienta de línea de comandos que puede usar 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 AWS CloudFormation plantillas AWS SAM y. También funciona con productos de terceros, como Terraform.

Inicio de un nuevo proyecto

Selecciona una de las plantillas iniciales o elige 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, consulta Crea tu aplicación en AWS SAM.

Compilación de tu 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, consulta Creación de su aplicación.

Realización de testeo y depuraciones locales

En su máquina local, simule eventos, pruebe APIs, 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 utilizar una aplicación como Docker para ejecutar contenedores en su máquina.

Para obtener más información, consultaPrueba de la aplicación y Depuración de la 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, consulta Implementación de la aplicación y los recursos.

Configure las canalizaciones CI/CD de implementación

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

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. Esto 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, consulta Implemente con CI/CD sistemas y canalizaciones.

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

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

En este caso, utilizamos el comando sam list para ver los recursos desplegados. Obtenemos el punto de conexión de la API 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, consulta Supervisión de la aplicación.

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

A medida que va desarrollando en tu máquina local, sincronice automáticamente los cambios con la nube. Consulta rápidamente los cambios y realiza 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

Invoca y transfiere 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:

Pasos a seguir a continuación

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