Qu'est-ce que le AWS Serverless Application Model (AWS SAM) ?

The AWS Serverless Application Model (AWS SAM) est une boîte à outils qui améliore l'expérience des développeurs en matière de création et d'exécution d'applications sans serveur sur AWS. AWS SAM offre de nombreux avantages :

Définir rapidement le code de votre infrastructure d'applications en utilisant moins de code

Créez des AWS SAM modèles pour définir le code de votre infrastructure d'applications sans serveur. Déployez vos modèles directement AWS CloudFormation pour provisionner vos ressources.

Gérer vos applications sans serveur tout au long de leur cycle de développement

Utilisez la CLI  AWS SAM pour gérer votre application sans serveur tout au long des phases de création, de construction, de déploiement, de test et de surveillance de votre cycle de vie de développement. Pour plus d’informations, consultez Utilisation de la CLI AWS SAM.

Attribuez rapidement des autorisations entre les ressources à l'aide de AWS SAM connecteurs

Utilisez des AWS SAM connecteurs dans vos AWS SAM modèles pour définir les autorisations entre vos AWS ressources. AWS SAM transforme votre code en autorisations IAM requises pour faciliter votre intention. Pour plus d’informations, consultez Gestion des autorisations de ressource avec des connecteurs AWS SAM.

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

Utilisez la AWS SAMCLI sam sync commande pour synchroniser automatiquement les modifications locales dans le cloud, accélérant ainsi vos flux de travail de développement et de test dans le cloud. Pour plus d’informations, consultez Utiliser sam sync.

Gérer vos applications Terraform sans serveur

Utilisez la CLI  AWS SAM pour effectuer un débogage et des tests locaux de vos fonctions et couches Lambda. Pour plus d’informations, consultez Prise en charge de Terraform par la CLI AWS SAM.

Rubriques

• Concepts de base
• Quelle est la spécification du AWS SAM modèle ?
• Qu'est-ce que le AWS SAM modèle ?
• Qu'est-ce que c'est AWS SAMCLI ?
• En savoir plus
• Étapes suivantes
• Concepts sans serveur

Concepts de base

AWS SAM se compose de trois parties principales :

1. AWS SAM spécification du modèle — Framework open source que vous pouvez utiliser pour définir votre infrastructure d'applications sans serveur. AWS Ce cadre est accessible via des AWS SAM modèles.

2. AWS SAM modèle : ce que vous utilisez pour accéder aux spécifications des AWS SAM modèles, le framework open source sur lequel vous pouvez définir votre infrastructure d'applications sans serveur. AWS Un AWS SAM modèle est une extension de AWS CloudFormation modèles avec des composants supplémentaires qui facilitent leur utilisation.

3. AWS SAM interface de ligne de commande (AWS SAMCLI) : 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.

Vous débutez dans le monde du sans serveur ?

Nous vous recommandons de passer en revueConcepts 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 :

• Construit sur AWS CloudFormation : 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 de vous familiariser avec 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

Qu'est-ce que le AWS SAM modèle ?

Un AWS SAM modèle est ce que vous utilisez pour accéder aux spécifications du AWS SAM modèle, le framework open source sur lequel vous pouvez 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: 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 :

• 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": "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 :

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

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

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

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.

Effectuer le débogage et les tests au niveau local

Sur votre ordinateur local, simulez des événements, testez des API, appelez 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.

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.

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.

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.

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, consultezDémarrer avec AWS SAM.