Comment AWS SAM fonctionne

Lorsque vous créez votre application sans serveur, vous allez interagir avec les composants suivants : AWS SAM

1. AWS SAM modèle— Un fichier important qui définit vos AWS ressources. Ce modèle inclut la spécification du AWS SAM modèle, le framework open source fourni avec une syntaxe abrégée simplifiée que vous utilisez pour définir les fonctions, les événements APIs, les configurations et les autorisations de votre application sans serveur. Ce fichier se trouve dans le AWS SAM projet, qui est le dossier de l'application créé lorsque vous exécutez la sam init commande.

2. AWS SAM CLI— Un outil de ligne de commande que vous pouvez utiliser avec votre AWS SAM projet et les intégrations tierces prises en charge pour créer et exécuter vos applications sans serveur. AWS SAMCLIC'est l'outil que vous utilisez pour exécuter des commandes sur votre AWS SAM projet et éventuellement le transformer en 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 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.

Vous débutez dans le monde du sans serveur ?

Nous vous recommandons de passer en revueConcepts sans serveur pour AWS Serverless Application Model.

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 :

• Construit sur AWS CloudFormation : vous utilisez la AWS CloudFormation syntaxe directement dans votre AWS SAM modèle, en tirant parti de sa prise en charge étendue des configurations de ressources et de propriétés. Si vous le connaissez déjà AWS CloudFormation, vous n'avez pas besoin d'apprendre un nouveau service pour gérer le code de votre infrastructure d'applications.

• Une extension de AWS CloudFormation — AWS SAM propose sa propre syntaxe unique qui vise spécifiquement à accélérer le développement sans serveur. Vous pouvez utiliser à la fois la AWS SAM syntaxe AWS CloudFormation et dans le même modèle.

• Une syntaxe abstraite et abrégée : en utilisant la syntaxe AWS SAM , vous pouvez définir votre infrastructure rapidement, en moins de lignes de code et avec moins de risques d'erreurs. Sa syntaxe est spécialement conçue pour faire abstraction de la complexité de la définition de votre infrastructure d'application sans serveur.

• Transformationnel : AWS SAM effectue le travail complexe de transformation de votre modèle en code nécessaire au provisionnement de votre infrastructure. AWS CloudFormation

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 d'obtention de tous les éléments d'une base de données via une requête HTTP. Elle se compose des éléments suivants :

1. Une fonction qui contient la logique de traitement de la demande.

2. Une API HTTP pour servir de communication entre le client (demandeur) et l'application.

3. Une base de données pour stocker les articles.

4. Des autorisations permettant à l'application de s'exécuter en toute sécurité.

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 :

• Fonction utilisant le AWS Lambda service.

• Une API HTTP utilisant le service Amazon API Gateway.

• Une base de données utilisant le service Amazon DynamoDB.

• Les autorisations AWS Identity and Access Management (IAM) nécessaires pour que ces services interagissent les uns avec les autres.

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 !

AWS CloudFormation Modèle transformé

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

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 :

• Initialiser rapidement un nouveau projet d'application.

• Créer votre application pour le déploiement.

• Effectuer le débogage et les tests au niveau local.

• Déployez votre application.

• Configurez les pipelines de CI/CD déploiement.

• Surveiller et dépanner votre application dans le cloud.

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

• Et bien plus encore !

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, testez APIs, 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.

Configuration des pipelines CI/CD de déploiement

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

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 CI/CD des systèmes et des pipelines.

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 le point de terminaison de notre API et l'appelons, 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 :

• L' AWS SAM atelier complet — Un atelier conçu pour vous enseigner les nombreuses fonctionnalités principales qu'il AWS SAM fournit.

• Sessions avec SAM — Série de vidéos créée par notre équipe AWS Serverless Developer Advocate sur l'utilisation AWS SAM.

• Serverless Land : site qui rassemble les dernières informations, blogs, vidéos, codes et ressources d'apprentissage pour le AWS sans-serveur.

Étapes suivantes

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