Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Initiation à la construction avec AWS SAM

Utilisez la AWS Serverless Application Model commande Command Line Interface (AWS SAMCLI) sam build pour préparer votre application sans serveur aux étapes suivantes de votre flux de travail de développement, telles que les tests locaux ou le déploiement sur le AWS Cloud. Cette commande crée un répertoire .aws-sam qui structure votre application dans un format et un emplacement que sam local et sam deploy nécessitent.

Création d'applications avec sam build

Avant de l'utilisersam build, pensez à configurer les éléments suivants :

Ces paramètres d'application peuvent être configurés lors de l'initialisation d'une application à l'aide de sam init.

En fonction de la configuration de votre application, la CLI  AWS SAM effectue les opérations suivantes :

Les principaux composants qui constituent vos artefacts de création dans le répertoire .aws-sam sont les suivants :

Test et déploiement au niveau local

Lorsque vous effectuez des tests locaux avec sam local ou un déploiement avec sam deploy, la CLI  AWS SAM effectue les opérations suivantes :

Lors du développement, si des modifications sont apportées à vos fichiers d'application originaux, exécutez sam build pour mettre à jour le répertoire .aws-sam avant de tester localement.

Bonnes pratiques

Options pour sam build

Création d'une seule ressource

Fournissez l'ID logique de la ressource pour ne créer que cette ressource. Voici un exemple :

$ sam build HelloWorldFunction

Pour créer une ressource d'une application ou d'une pile imbriquée, fournissez l'identifiant logique de l'application ou de la pile avec l'identifiant logique de la ressource en utilisant le format <stack-logical-id>/<resource-logical-id> :

$ sam build MyNestedStack/MyFunction

Création d'une fonction Lambda à l'intérieur d'un conteneur fourni

L'option --use-container télécharge une image de conteneur et l'utilise pour créer vos fonctions Lambda. Le conteneur local est ensuite référencé dans votre fichier .aws-sam/build.toml.

Cette option nécessite que Docker soit installé. Pour obtenir des instructions, veuillez consulter Installation de Docker.

Voici un exemple de cette commande :

$ sam build --use-container

Vous pouvez spécifier l'image de conteneur à utiliser avec l'option --build-image. Voici un exemple :

$ sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x

Pour spécifier l'image du conteneur à utiliser pour une seule fonction, fournissez l'ID logique de la fonction. Voici un exemple :

$ sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12

Transmettre des variables d'environnement au conteneur de création

Utilisez --container-env-var pour transmettre les variables d'environnement au conteneur de création. Voici un exemple :

$ sam build --use-container --container-env-var Function1.GITHUB_TOKEN=<token1> --container-env-var GLOBAL_ENV_VAR=<global-token>

Pour transmettre des variables d'environnement à partir d'un fichier, utilisez l'option --container-env-var-file. Voici un exemple :

$ sam build --use-container --container-env-var-file <env.json>

Exemple de fichier env.json :

{
  "MyFunction1": {
    "GITHUB_TOKEN": "TOKEN1"
  },
  "MyFunction2": {
    "GITHUB_TOKEN": "TOKEN2"
  }
}

Accélérez la création d'applications contenant plusieurs fonctions

Lorsque vous exécutez sam build sur une application comportant plusieurs fonctions, la CLI  AWS SAM crée chaque fonction une par une. Pour accélérer le processus de création, utilisez l'option --parallel. Cela crée toutes les fonctions et couches en même temps.

Voici un exemple de cette commande :

$ sam build —-parallel

Accélérez les temps de création en créant votre projet dans le dossier source

Pour les systèmes d'exécution et les méthodes de création pris en charge, vous pouvez utiliser l'option --build-in-source permettant de créer votre projet directement dans le dossier source. Par défaut, il est AWS SAM CLI compilé dans un répertoire temporaire, ce qui implique de copier le code source et les fichiers de projet. Avec--build-in-source, les AWS SAM CLI builds se trouvent directement dans votre dossier source, ce qui accélère le processus de compilation en supprimant le besoin de copier des fichiers dans un répertoire temporaire.

Pour obtenir une liste des systèmes d’exécution ainsi que des méthodes de création pris en charge, consultez --build-in-source.

Résolution des problèmes

Pour résoudre le problème AWS SAMCLI, voirRésolution des problèmes de la CLI AWS SAM.

Exemples

Création d'une application utilisant une exécution native et un type de package .zip

Pour cet exemple, consultez Tutoriel : Déployer une application Hello World avec AWS SAM.

Création d'une application utilisant une exécution native et un type de package d'images

Tout d'abord, nous exécutons sam init pour initialiser une nouvelle application. Au cours du flux interactif, nous sélectionnons le type de package Image. Voici un exemple :

$ sam init
...
Which template source would you like to use?
        1 - AWS Quick Start Templates
        2 - Custom Template Location
Choice: 1

Choose an AWS Quick Start application template
        1 - Hello World Example
        2 - Multi-step workflow
        3 - Serverless API
        4 - Scheduled task
        5 - Standalone function
        6 - Data processing
        7 - Hello World Example With Powertools
        8 - Infrastructure event management
        9 - Serverless Connector Hello World Example
        10 - Multi-step workflow with Connectors
        11 - Lambda EFS example
        12 - DynamoDB Example
        13 - Machine Learning
Template: 1

Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER

Which runtime would you like to use?
        ...
        10 - java8
        11 - nodejs20.x
        12 - nodejs18.x
        13 - nodejs16.x
        ...
Runtime: 12

What package type would you like to use?
        1 - Zip
        2 - Image
Package type: 2

Based on your selections, the only dependency manager available is npm.
We will proceed copying the template using npm.

Would you like to enable X-Ray tracing on the function(s) in your application?  [y/N]: ENTER

Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER

Project name [sam-app]: ENTER

Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)

    -----------------------
    Generating application:
    -----------------------
    Name: sam-app
    Base Image: amazon/nodejs18.x-base
    Architectures: x86_64
    Dependency Manager: npm
    Output Directory: .
    Configuration file: sam-app/samconfig.toml

    Next steps can be found in the README file at sam-app/README.md
    
...

AWS SAMCLIInitialise une application et crée le répertoire de projet suivant :

sam-app
├── README.md
├── events
│   └── event.json
├── hello-world
│   ├── Dockerfile
│   ├── app.mjs
│   ├── package.json
│   └── tests
│       └── unit
│           └── test-handler.mjs
├── samconfig.toml
└── template.yaml

Ensuite, nous exécutons sam build pour créer notre application :

sam-app $ sam build
Building codeuri: /Users/.../build-demo/sam-app runtime: None metadata: {'DockerTag': 'nodejs18.x-v1', 'DockerContext': '/Users/.../build-demo/sam-app/hello-world', 'Dockerfile': 'Dockerfile'} architecture: arm64 functions: HelloWorldFunction
Building image for HelloWorldFunction function
Setting DockerBuildArgs: {} for HelloWorldFunction function
Step 1/4 : FROM public.ecr.aws/lambda/nodejs:18
 ---> f5b68038c080
Step 2/4 : COPY app.mjs package*.json ./
 ---> Using cache
 ---> 834e565aae80
Step 3/4 : RUN npm install
 ---> Using cache
 ---> 31c2209dd7b5
Step 4/4 : CMD ["app.lambdaHandler"]
 ---> Using cache
 ---> 2ce2a438e89d
Successfully built 2ce2a438e89d
Successfully tagged helloworldfunction:nodejs18.x-v1

Build Succeeded

Built Artifacts  : .aws-sam/build
Built Template   : .aws-sam/build/template.yaml

Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided

Création d'une application qui inclut un langage de programmation compilé

Dans cet exemple, nous créons une application contenant une fonction Lambda à l'aide de l'exécution Go.

Tout d'abord, nous initialisons une nouvelle application en utilisant sam init et configurons notre application pour qu'elle utilise Go :

$ sam init

...

Which template source would you like to use?
        1 - AWS Quick Start Templates
        2 - Custom Template Location
Choice: 1

Choose an AWS Quick Start application template
        1 - Hello World Example
        2 - Multi-step workflow
        3 - Serverless API
        ...
Template: 1

Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER

Which runtime would you like to use?
        ...
        4 - dotnetcore3.1
        5 - go1.x
        6 - go (provided.al2)
        ...
Runtime: 5

What package type would you like to use?
        1 - Zip
        2 - Image
Package type: 1

Based on your selections, the only dependency manager available is mod.
We will proceed copying the template using mod.

Would you like to enable X-Ray tracing on the function(s) in your application?  [y/N]: ENTER

Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER

Project name [sam-app]: ENTER

Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)

    -----------------------
    Generating application:
    -----------------------
    Name: sam-app
    Runtime: go1.x
    Architectures: x86_64
    Dependency Manager: mod
    Application Template: hello-world
    Output Directory: .
    Configuration file: sam-app/samconfig.toml
    
    Next steps can be found in the README file at sam-app-go/README.md
        
...

AWS SAMCLIInitialise ensuite l'application. Voici un exemple de la structure du répertoire de l'application :

sam-app
├── Makefile
├── README.md
├── events
│   └── event.json
├── hello-world
│   ├── go.mod
│   ├── go.sum
│   ├── main.go
│   └── main_test.go
├── samconfig.toml
└── template.yaml

Nous référençons le fichier README.md pour les exigences de cette application.

...
## Requirements
* AWS CLI already configured with Administrator permission
* [Docker installed](https://www.docker.com/community-edition)
* [Golang](https://golang.org)
* SAM CLI - [Install the SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
...

Ensuite, nous exécutons sam local invoke pour tester notre fonction. Cette commande provoque une erreur, car Go n'est pas installé sur notre machine locale :

sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-go1.x
Building image.................................................................................................................................................................................................................................................
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.

Mounting /Users/.../Playground/build/sam-app/hello-world as /var/task:ro,delegated inside runtime container
START RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Version: $LATEST
fork/exec /var/task/hello-world: no such file or directory: PathError
null
END RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31
REPORT RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31  Init Duration: 0.88 ms  Duration: 175.75 ms Billed Duration: 176 ms Memory Size: 128 MB     Max Memory Used: 128 MB
{"errorMessage":"fork/exec /var/task/hello-world: no such file or directory","errorType":"PathError"}%

Ensuite, nous exécutons sam build pour créer notre application. Nous rencontrons une erreur car Go n'est pas installée sur notre machine locale :

sam-app $ sam build
Starting Build use cache
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../Playground/build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction

Build Failed
Error: GoModulesBuilder:Resolver - Path resolution for runtime: go1.x of binary: go was not successful

Bien que nous puissions configurer notre machine locale pour créer correctement notre fonction, nous utilisons plutôt l'option --use-container avec sam build. AWS SAMCLITélécharge une image de conteneur, construit notre fonction en utilisant le natif GoModulesBuilder et copie le binaire obtenu .aws-sam/build/HelloWorldFunction dans notre répertoire.

sam-app $ sam build --use-container
Starting Build use cache
Starting Build inside a container
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction

Fetching public.ecr.aws/sam/build-go1.x:latest-x86_64 Docker container image.....................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Mounting /Users/.../build/sam-app/hello-world as /tmp/samcli/source:ro,delegated inside runtime container
Running GoModulesBuilder:Build

Build Succeeded

Built Artifacts  : .aws-sam/build
Built Template   : .aws-sam/build/template.yaml

Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided

Voici un exemple du répertoire .aws-sam :

.aws-sam
├── build
│   ├── HelloWorldFunction
│   │   └── hello-world
│   └── template.yaml
├── build.toml
├── cache
│   └── c860d011-4147-4010-addb-2eaa289f4d95
│       └── hello-world
└── deps

Ensuite, nous exécutons sam local invoke. Notre fonction est appelée avec succès :

sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image is up-to-date
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.

Mounting /Users/.../Playground/build/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container
START RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Version: $LATEST
END RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479
REPORT RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479  Init Duration: 1.20 ms  Duration: 1782.46 ms        Billed Duration: 1783 ms        Memory Size: 128 MB     Max Memory Used: 128 MB
{"statusCode":200,"headers":null,"multiValueHeaders":null,"body":"Hello, 72.21.198.67\n"}%

En savoir plus

Pour en savoir plus sur l'utilisation de la commande sam build, reportez-vous à ce qui suit :