Comment AWS SAM fonctionne

AWS SAM se compose de deux composants principaux que vous utilisez pour créer votre application sans serveur :

Pour exprimer les ressources, les mappages de sources d'événements et les autres propriétés qui définissent votre application sans serveur, vous définissez les ressources et développez votre application dans le AWS SAM modèle et dans d'autres fichiers de votre AWS SAM projet. Vous utilisez le AWS SAM CLI pour exécuter des commandes sur votre AWS SAM projet, c'est ainsi que vous initialisez, créez, testez et déployez votre application sans serveur.

Quelle est la spécification du AWS SAM modèle ?

La spécification du AWS SAM modèle est un framework open source que vous pouvez utiliser pour définir et gérer le code de votre infrastructure d'applications sans serveur. La spécification du AWS SAM modèle est la suivante :

Quels sont le AWS SAM projet et le AWS SAM modèle ?

Le AWS SAM projet inclut le AWS SAM modèle qui contient la spécification du AWS SAM modèle. Cette spécification est le framework open source que vous utilisez pour définir votre infrastructure d'applications sans serveur AWS, avec certains composants supplémentaires qui facilitent leur utilisation. En ce sens, les AWS SAM modèles sont une extension des AWS CloudFormation modèles.

Voici un exemple d'application de base sans serveur. Cette application traite les demandes visant à obtenir tous les éléments d'une base de données par le biais d'une HTTP demande. Elle se compose des éléments suivants :

Le code d'infrastructure de cette application peut être défini dans le modèle AWS SAM suivant :

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 lignes de code, l'infrastructure suivante est définie :

Pour provisionner cette infrastructure, le modèle est déployé sur AWS CloudFormation. Lors du déploiement, AWS SAM transforme les 23 lignes de code en la AWS CloudFormation syntaxe requise pour générer ces ressources dans AWS. Le AWS CloudFormation modèle transformé contient plus de 200 lignes de code !

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

En utilisant AWS SAM, vous définissez 23 lignes de code d'infrastructure. AWS SAM transforme votre code en plus de 200 lignes de AWS CloudFormation code nécessaires au provisionnement de votre application.

Qu'est-ce que le AWS SAM CLI?

Le AWS SAM CLI est un outil de ligne de commande que vous pouvez utiliser avec des AWS SAM modèles et des intégrations tierces prises en charge pour créer et exécuter vos applications sans serveur. Utilisez le AWS SAM CLI par :

Le AWS SAM CLI est mieux utilisé lorsqu'il est utilisé avec AWS SAM et des AWS CloudFormation modèles. Il fonctionne également avec des produits tiers tels que Terraform.

Initialiser un nouveau projet

Sélectionnez des modèles de départ ou choisissez un emplacement de modèle personnalisé pour commencer un nouveau projet.

Ici, nous utilisons la commande sam init pour initialiser un nouveau projet d'application. Nous sélectionnons le projet Hello World Example pour commencer. Le AWS SAM CLI télécharge un modèle de démarrage et crée la structure de dossiers de notre projet.

Pour en savoir plus, consultez Créez votre application dans AWS SAM.

Créer votre application pour le déploiement

Regroupez les dépendances de vos fonctions et organisez le code de votre projet et la structure de dossiers pour préparer le déploiement.

Ici, nous utilisons la commande sam build pour préparer notre application en vue du déploiement. Le AWS SAM CLI crée un .aws-sam répertoire et organise les dépendances de nos applications et les fichiers qui s'y trouvent pour le déploiement.

Pour en savoir plus, consultez Créez votre application.

Effectuer le débogage et les tests au niveau local

Sur votre machine locale, simulez des événements, testezAPIs, invoquez des fonctions, etc. pour déboguer et tester votre application.

Ici, nous utilisons la commande sam local invoke pour appeler notre HelloWorldFunction localement. Pour ce faire, le AWS SAM CLI crée un conteneur local, construit notre fonction, l'invoque et affiche les résultats. Vous pouvez utiliser une application telle que Docker pour exécuter des conteneurs sur votre machine.

Pour de plus amples informations, veuillez consulter Testez votre application et Déboguez votre application.

Déploiement de votre application

Configurez les paramètres de déploiement de votre application et déployez-la AWS dans le cloud pour provisionner vos ressources.

Ici, nous utilisons la commande sam deploy --guided pour déployer notre application via un flux interactif. Le AWS SAM CLI nous guide dans la configuration des paramètres de déploiement de notre application, transforme notre modèle en AWS CloudFormation et le déploie AWS CloudFormation pour créer nos ressources.

Pour en savoir plus, consultez Déployez votre application et vos ressources.

Configurer les pipelines de déploiement CI/CD

Créer des pipelines d'intégration et de livraison continues (CI/CD) sécurisés à l'aide d'un système CI/CD pris en charge.

Ici, nous utilisons la commande sam pipeline init --bootstrap pour configurer un pipeline de déploiement CI/CD pour notre application. Le AWS SAM CLI nous guide à travers nos options et génère les AWS ressources et le fichier de configuration à utiliser avec notre système CI/CD.

Pour en savoir plus, consultez Déployez avec des systèmes et des pipelines CI/CD.

Surveiller et dépanner votre application dans le cloud

Consultez les informations importantes sur vos ressources déployées, collectez les journaux et utilisez les outils de surveillance intégrés tels que AWS X-Ray.

Ici, nous utilisons la commande sam list pour visualiser nos ressources déployées. Nous obtenons notre API point de terminaison et l'invoquons, ce qui déclenche notre fonction. Ensuite, nous l'utilisons sam logs pour consulter les journaux de nos fonctions.

Pour en savoir plus, consultez Surveillez votre application.

Synchroniser les modifications locales dans le cloud au fur et à mesure de votre développement

Au fur et à mesure que vous développez sur votre ordinateur local, synchronisez automatiquement les modifications dans le cloud. Visualisez rapidement vos modifications et effectuez des tests et des validations dans le cloud.

Ici, nous utilisons la sam sync --watch commande pour avoir AWS SAM CLI surveillez les changements locaux. Nous modifions notre HelloWorldFunction code et le AWS SAM CLI détecte automatiquement le changement et déploie nos mises à jour dans le cloud.

Testez les ressources prises en charge dans le cloud

Invoquez et transmettez des événements aux ressources prises en charge dans le cloud.

Ici, nous utilisons la commande sam remote invoke pour tester une fonction Lambda déployée dans le cloud. Nous appelons notre fonction Lambda et recevons ses journaux et sa réponse. Avec notre fonction Lambda configurée pour diffuser les réponses, le AWS SAM CLI renvoie sa réponse en temps réel.

En savoir plus

Pour en savoir plus AWS SAM, consultez les ressources suivantes :

Étapes suivantes

Si c'est la première fois que vous l'utilisez AWS SAM, consultezCommencer avec AWS SAM.