¿Qué es el AWS Serverless Application Model (AWS SAM)? - AWS Serverless Application Model
Conceptos básicos¿Cuál es la especificación AWS SAM de la plantilla?¿Qué es la AWS SAM plantilla?¿Qué es el? AWS SAMCLIMás informaciónSiguientes pasos

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

¿Qué es el AWS Serverless Application Model (AWS SAM)?

El AWS Serverless Application Model (AWS SAM) es un conjunto de herramientas que mejora la experiencia de los desarrolladores a la hora de crear y ejecutar aplicaciones sin servidor. AWS AWS SAM ofrece una variedad de beneficios:

Defina el código de infraestructura de su aplicación rápidamente, utilizando menos código

Cree AWS SAM plantillas para definir el código de infraestructura de aplicaciones sin servidor. Implemente sus plantillas directamente AWS CloudFormation para aprovisionar sus recursos.

Administre las aplicaciones sin servidor durante todo su ciclo de vida de desarrollo

Use la CLI de AWS SAM para administrar su aplicación sin servidor durante las fases de autoría, creación, implementación, prueba y supervisión de su ciclo de vida de desarrollo. Para obtener más información, consulte Uso de la CLI de AWS SAM..

Aprovisione rápidamente los permisos entre los recursos con AWS SAM conectores

Usa AWS SAM conectores en tus AWS SAM plantillas para definir los permisos entre tus AWS recursos. AWS SAM transforma tu código en los permisos de IAM necesarios para facilitar tu intención. Para obtener más información, consulte Para obtener más información, consulte administración de los permisos de recursos con conectores de AWS SAM..

Sincronice de forma continua los cambios locales en la nube a medida que vaya desarrollando contenido

Utilice el AWS SAMCLI sam sync comando para sincronizar automáticamente los cambios locales con la nube, lo que agiliza los flujos de trabajo de desarrollo y pruebas en la nube. Para obtener más información, consulte Uso de sam sync.

Gestione sus aplicaciones de Terraform sin servidor

Use la CLI de AWS SAM para realizar la depuración y las pruebas locales de las funciones y capas de Lambda. Para obtener más información, consulte Compatibilidad de la CLI de AWS SAM con Terraform.

Temas

Conceptos básicos

AWS SAM consta de tres partes principales:

  1. AWS SAM especificación de plantilla: un marco de código abierto que puede utilizar para definir su infraestructura de aplicaciones sin servidor. AWS Se accede a este marco mediante AWS SAM plantillas.

  2. AWS SAM plantilla: lo que se utiliza para acceder a las especificaciones de la AWS SAM plantilla, el marco de código abierto que se puede utilizar para definir la infraestructura de aplicaciones sin servidor. AWS Una AWS SAM plantilla es una extensión de AWS CloudFormation plantillas con algunos componentes adicionales que facilitan el trabajo con ellas.

  3. AWS SAM interfaz de línea de comandos (AWS SAMCLI): herramienta de línea de comandos que puede utilizar con AWS SAM plantillas e integraciones de terceros compatibles para crear y ejecutar aplicaciones sin servidor.

¿Eres nuevo en la tecnología sin servidor?

Le recomendamos que haga una reseñaConceptos sobre sistemas 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:

  • Basado en AWS CloudFormation: utilice la AWS CloudFormation sintaxis directamente en la AWS SAM plantilla y aproveche su amplia compatibilidad con las configuraciones de recursos y propiedades. Si ya lo conoce AWS CloudFormation, no necesita aprender un nuevo servicio para administrar el código de infraestructura de sus aplicaciones.

  • Una extensión de AWS CloudFormation: AWS SAM ofrece su propia sintaxis única que se centra específicamente en acelerar el desarrollo sin servidores. Puede usar la AWS SAM sintaxis AWS CloudFormation y la sintaxis en la misma plantilla.

  • Una sintaxis abstracta y abreviada: con la sintaxis de AWS SAM , puede definir su infraestructura rápidamente, en menos líneas de código y con una menor probabilidad de errores. Su sintaxis está especialmente diseñada para eliminar la complejidad que implica definir la infraestructura de aplicaciones sin servidor.

  • Transformacional: AWS SAM realiza la compleja tarea de transformar la plantilla en el código necesario para aprovisionar la infraestructura. AWS CloudFormation

¿Qué es la AWS SAM plantilla?

Una AWS SAM plantilla es lo que se utiliza para acceder a las especificaciones de la AWS SAM plantilla, el marco de código abierto en el que se puede definir la infraestructura de aplicaciones sin servidor AWS, con algunos componentes adicionales que facilitan el trabajo con ellas. 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:

  1. Función que contiene la lógica necesaria para procesar la solicitud.

  2. Una API HTTP que sirve de comunicación entre el cliente (solicitante) y la aplicación.

  3. Una base de datos para almacenar elementos.

  4. Permisos para que la aplicación se ejecute de forma segura.

Arquitectura de aplicación de una aplicación sencilla sin servidor.

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:

  • Una función que utiliza el AWS Lambda servicio.

  • Una API HTTP que utiliza el servicio Amazon API Gateway.

  • Una base de datos que utiliza el servicio Amazon DynamoDB.

  • Los permisos AWS Identity and Access Management (IAM) necesarios para que estos servicios interactúen entre sí.

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:

  • Inicializar rápidamente un nuevo proyecto de aplicación.

  • Crear su aplicación para su implementación.

  • Realizar pruebas y depuraciones locales.

  • Implemente la aplicación.

  • Configurar las canalizaciones de implementación de CI/CD.

  • Supervisar y solucionar los problemas de su aplicación en la nube.

  • Sincronizar los cambios locales con la nube a medida que vaya desarrollándose.

  • Y mucho más.

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.

Se utiliza sam init para iniciar un nuevo proyecto de aplicación con la CLI de 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.

Se utiliza sam build para preparar una aplicación para su implementación.

Realización de pruebas y depuraciones locales

En la máquina local, simule eventos, pruebe las API, 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.

Usar el AWS SAMCLI sam local invoke comando para invocar una función de forma local.

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.

Uso del AWS SAMCLI sam deploy comando para implementar una aplicación en la AWS nube.

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.

Uso del AWS SAMCLI sam pipeline init --bootstrap comando para configurar una canalización de CI/CD con nuestro sistema de CI/CD preferido.

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 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.

Uso del AWS SAMCLI sam list comando para obtener nuestro punto final de API. Luego, usamos sam logs para ver los registros de la funció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.

Uso del AWS SAMCLI sam sync comando para sincronizar los cambios locales con la AWS 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.

Uso del AWS SAMCLI sam remote invoke comando para probar nuestra función implementada en la AWS nube.

Más información

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

  • El AWS SAM taller completo: un taller diseñado para enseñarle muchas de las principales funciones que AWS SAM ofrece.

  • Sesiones con SAM: serie de vídeos sobre su uso AWS SAM creada por nuestro equipo de AWS Serverless Developer Advocate.

  • Serverless Land: sitio que reúne la información más reciente, blogs, vídeos, códigos y recursos de aprendizaje sobre sistemas sin servidor. AWS

Siguientes pasos

Si es la primera vez que lo usa AWS SAM, consulte. Introducción a AWS SAM