Comment AWS SAM fonctionne

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

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 SAMCLI pour exécuter des commandes sur votre AWS SAM projet, c'est-à-dire pour initialiser, créer, tester et déployer 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: 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 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 c'est AWS SAMCLI ?

AWS SAMCLIIl s'agit d'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 la CLI  AWS SAM pour :

AWS SAMCLIIl est préférable de l'utiliser avec AWS SAM des AWS CloudFormation modèles. Elle 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. La CLI  AWS SAM télécharge un modèle de démarrage et crée la structure de répertoires 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. La CLI  AWS SAM crée un répertoire .aws-sam et organise les dépendances et les fichiers de nos applications 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, la CLI  AWS SAM crée un conteneur local, crée 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. Il nous AWS SAMCLI 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. Il nous AWS SAMCLI 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 commande sam sync --watch pour que la CLI  AWS SAM surveille les modifications locales. Nous modifions notre code HelloWorldFunction et la CLI  AWS SAM détecte automatiquement la modification 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. Notre fonction Lambda étant configurée pour diffuser les réponses, la CLI  AWS SAM diffuse 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.