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.
# Déployez votre application et vos ressources avec AWS SAM
Le déploiement de votre application fournit et configure vos AWS ressources dans le AWS cloud, ce qui permet à votre application de s'exécuter dans le cloud. AWS SAM utilise [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)comme mécanisme de déploiement sous-jacent. AWS SAM utilise les artefacts de construction que vous créez lors de l'exécution de la **sam build** commande comme entrées standard pour le déploiement de votre application sans serveur.
Vous pouvez ainsi déployer votre application sans serveur manuellement ou automatiser les déploiements. AWS SAM Pour automatiser les déploiements, vous utilisez des AWS SAM pipelines dotés d'un système d'intégration et de déploiement continus (CI/CD) de votre choix. Votre pipeline de déploiement est une séquence automatique d'étapes effectuées pour publier une nouvelle version de votre application sans serveur.
Les rubriques de cette section fournissent des conseils sur les déploiements automatisés et manuels. Pour déployer votre application manuellement, vous devez utiliser des AWS SAMCLI commandes. Pour automatiser les déploiements, consultez les rubriques de cette section. Ils fournissent spécifiquement un contenu détaillé sur l'automatisation des déploiements à l'aide de pipelines et d'un CI/CD système. Cela inclut la génération d'un pipeline de démarrage, la configuration de l'automatisation, le dépannage des déploiements, l'utilisation de l'authentification utilisateur OpenID Connect (OIDC) et le téléchargement de fichiers locaux lors du déploiement.
**Topics**
+ [Présentation du déploiement avec AWS SAM](using-sam-cli-deploy.md)
+ [Options pour déployer votre application avec AWS SAM](deploying-options.md)
+ [Utilisation CI/CD de systèmes et de pipelines pour déployer avec AWS SAM](deploying-cicd-overview.md)
+ [Présentation de l'utilisation sam sync de la synchronisation avec AWS Cloud](using-sam-cli-sync.md)
# Présentation du déploiement avec AWS SAM
Utilisez la AWS Serverless Application Model commande Command Line Interface (AWS SAMCLI) `sam deploy` pour déployer votre application sans serveur sur. AWS Cloud
+ Pour une introduction à la AWS SAMCLI, voir[Qu'est-ce que c'est AWS SAMCLI ?](what-is-sam-overview.md#what-is-sam-cli).
+ Pour obtenir la liste des options de commande `sam deploy`, consultez [sam deploy](sam-cli-command-reference-sam-deploy.md).
+ Pour un exemple d'utilisation de `sam deploy` dans le cadre d'un flux de travail de développement classique, consultez [Étape 3 : Déployez votre application sur AWS Cloud](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-deploy).
**Topics**
+ [Conditions préalables](#using-sam-cli-deploy-prerequisites)
+ [Déploiement d'applications avec sam deploy](#using-sam-cli-deploy-deploying)
+ [Bonnes pratiques](#using-sam-cli-deploy-best)
+ [Options pour sam deploy](#using-sam-cli-deploy-options)
+ [Résolution des problèmes](#using-sam-cli-deploy-troubleshooting)
+ [Exemples](#using-sam-cli-deploy-examples)
+ [En savoir plus](#using-sam-cli-deploy-learn)
## Conditions préalables
Pour utiliser `sam deploy`, installez la CLI AWS SAM en procédant comme suit :
+ [AWS SAM prérequis](prerequisites.md).
+ [Installer la CLI AWS SAM](install-sam-cli.md).
Avant d'utiliser `sam deploy`, nous vous recommandons d'avoir des connaissances de base sur les points suivants :
+ [Configuration de la CLI AWS SAM](using-sam-cli-configure.md).
+ [Créez votre application dans AWS SAM](using-sam-cli-init.md).
+ [Initiation à la construction avec AWS SAM](using-sam-cli-build.md).
## Déploiement d'applications avec sam deploy
Lorsque vous déployez une application sans serveur pour la première fois, utilisez l'option `--guided`. La CLI AWS SAM vous guidera à travers un flux interactif pour configurer les paramètres de déploiement de votre application.
**Pour déployer une application à l'aide du flux interactif**
1. Accédez au répertoire racine de votre projet. Il s'agit du même emplacement que celui de votre AWS SAM modèle.
```
$ cd sam-app
```
1. Exécutez la commande suivante :
```
$ sam deploy --guided
```
1. Au cours du flux interactif, la CLI AWS SAM vous invite à configurer les paramètres de déploiement de votre application.
Les crochets (`[ ]`) indiquent les valeurs par défaut. Laissez la réponse vide pour sélectionner la valeur par défaut. Les valeurs par défaut sont obtenues à partir des fichiers de configuration suivants :
+ `~/.aws/config`— Les paramètres généraux de votre AWS compte.
+ `~/.aws/credentials`— Les informations d'identification de votre AWS compte.
+ `/samconfig.toml` : le fichier de configuration de votre projet.
Fournissez des valeurs en répondant aux invites de la CLI AWS SAM. Par exemple, vous pouvez saisir `y` pour **oui**, `n` pour **non** ou des valeurs de chaîne.
La CLI AWS SAMécrit vos réponses dans le fichier `samconfig.toml` de votre projet. Pour les déploiements suivants, vous pouvez utiliser `sam deploy` pour déployer à l'aide de ces valeurs configurées. Pour reconfigurer ces valeurs, utilisez à nouveau `sam deploy --guided` ou modifiez directement vos fichiers de configuration.
Voici un exemple de résultat :
```
sam-app $ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [sam-app]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: ENTER
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
```
1. Ensuite, AWS SAMCLI déploie votre application dans le AWS Cloud. Pendant le déploiement, la progression s'affiche dans votre invite de commande. Les principales étapes du déploiement sont les suivantes :
+ Pour les applications dont AWS Lambda les fonctions sont regroupées sous forme d'archive de fichier .zip, le package est AWS SAMCLI compressé et chargé dans un compartiment Amazon Simple Storage Service (Amazon S3). Si nécessaire, la CLI AWS SAM créera un nouveau compartiment.
+ Pour les applications contenant un package de fonctions Lambda en tant qu'image de conteneur, la CLI AWS SAM charge l'image dans Amazon Elastic Container Registry (Amazon ECR). Si nécessaire, la CLI AWS SAM créera un nouveau référentiel.
+ AWS SAMCLIcrée un ensemble de AWS CloudFormation modifications et déploie votre application CloudFormation sous forme de pile.
+ AWS SAMCLImodifie votre AWS SAM modèle déployé avec la nouvelle `CodeUri` valeur de vos fonctions Lambda.
Vous trouverez ci-dessous un exemple du résultat du déploiement de la CLI AWS SAM :
```
Looking for resources needed for deployment:
Managed S3 bucket: aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
A different default S3 bucket can be set in samconfig.toml and auto resolution of buckets turned off by setting resolve_s3=False
Parameter "stack_name=sam-app" in [default.deploy.parameters] is defined as a global parameter [default.global.parameters].
This parameter will be only saved under [default.global.parameters] in /Users/.../sam-app/samconfig.toml.
Saved arguments to config file
Running 'sam deploy' for future deployments will use the parameters saved above.
The above parameters can be changed by modifying samconfig.toml
Learn more about samconfig.toml syntax at
https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html
Uploading to sam-app-zip/da3c598813f1c2151579b73ad788cac8 262144 / 619839 (42.29%)Uploading to sam-app-zip/da3c598813f1c2151579b73ad788cac8 524288 / 619839 (84.58%)Uploading to sam-app-zip/da3c598813f1c2151579b73ad788cac8 619839 / 619839 (100.00%)
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
Uploading to sam-app-zip/be84c20f868068e4dc4a2c11966edf2d.template 1212 / 1212 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
-------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
-------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A
oWorldPermissionProd n
+ Add HelloWorldFunctionRole AWS::IAM::Role N/A
+ Add HelloWorldFunction AWS::Lambda::Function N/A
+ Add ServerlessRestApiDeplo AWS::ApiGateway::Deplo N/A
yment47fc2d5f9d yment
+ Add ServerlessRestApiProdS AWS::ApiGateway::Stage N/A
tage
+ Add ServerlessRestApi AWS::ApiGateway::RestA N/A
pi
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680559234/d9f58a77-98bc-41cd-b9f4-433a5a450d7a
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-03 12:00:50 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
-------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
-------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
Initiated
CREATE_COMPLETE AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction Resource creation
Initiated
CREATE_COMPLETE AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi Resource creation
pi Initiated
CREATE_COMPLETE AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell Resource creation
n oWorldPermissionProd Initiated
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo Resource creation
yment yment47fc2d5f9d Initiated
CREATE_COMPLETE AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS Resource creation
tage Initiated
CREATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_COMPLETE AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_COMPLETE AWS::CloudFormation::S sam-app-zip -
tack
-------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-zip-
HelloWorldFunctionRole-11ZOGSCG28H0M
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://njzfhdmls0.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:sam-app-
HelloWorldFunction-XPqNX4TBu7qn
-------------------------------------------------------------------------------------------------
Successfully created/updated stack - sam-app-zip in us-west-2
```
1. Pour visualiser votre application déployée, procédez comme suit :
1. Ouvrez la CloudFormation console directement avec l'URL [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Sélectionner **Piles**
1. Identifiez votre pile par le nom de l'application et sélectionnez-la.
### Vérifiez les modifications avant le déploiement
Vous pouvez configurer le AWS SAMCLI pour afficher votre ensemble de CloudFormation modifications et demander une confirmation avant le déploiement.
**Pour confirmer les modifications avant le déploiement**
1. Lors de `sam deploy --guided`, saisissez **Y** pour confirmer les modifications avant le déploiement.
```
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: Y
```
Vous pouvez également modifier votre fichier `samconfig.toml` comme suit :
```
[default.deploy]
[default.deploy.parameters]
confirm_changeset = true
```
1. Pendant le déploiement, la CLI AWS SAM vous demandera de confirmer les modifications avant le déploiement. Voici un exemple :
```
Waiting for changeset to be created..
CloudFormation stack changeset
-------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
-------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A
oWorldPermissionProd n
+ Add HelloWorldFunctionRole AWS::IAM::Role N/A
+ Add HelloWorldFunction AWS::Lambda::Function N/A
+ Add ServerlessRestApiDeplo AWS::ApiGateway::Deplo N/A
yment47fc2d5f9d yment
+ Add ServerlessRestApiProdS AWS::ApiGateway::Stage N/A
tage
+ Add ServerlessRestApi AWS::ApiGateway::RestA N/A
pi
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680559234/d9f58a77-98bc-41cd-b9f4-433a5a450d7a
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
```
### Spécifier des paramètres supplémentaires lors du déploiement
Vous pouvez spécifier des valeurs de paramètres supplémentaires à configurer lors du déploiement. Pour ce faire, modifiez votre modèle AWS SAM et configurez la valeur de votre paramètre pendant le déploiement.
**Pour spécifier des paramètres supplémentaires**
1. Modifiez la `Parameters` section de votre AWS SAM modèle. Voici un exemple :
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Globals:
...
Parameters:
DomainName:
Type: String
Default: example
Description: Domain name
```
1. Exécutez `sam deploy --guided`. Voici un exemple de résultat :
```
sam-app $ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [sam-app-zip]: ENTER
AWS Region [us-west-2]: ENTER
Parameter DomainName [example]: ENTER
```
### Configuration de la signature de code pour vos fonctions Lambda
Vous pouvez configurer la signature de code pour vos fonctions Lambda au moment du déploiement. Pour ce faire, modifiez votre AWS SAM modèle et configurez la signature de code lors du déploiement.
**Pour configurer la signature de code**
1. Spécifiez `CodeSigningConfigArn` dans votre AWS SAM modèle. Voici un exemple :
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.7
CodeSigningConfigArn: arn:aws:lambda:us-east-1:111122223333:code-signing-config:csc-12e12345db1234567
```
1. Exécutez `sam deploy --guided`. La CLI AWS SAM vous invite à configurer la signature de code. Voici un exemple de résultat :
```
#Found code signing configurations in your function definitions
Do you want to sign your code? [Y/n]: ENTER
#Please provide signing profile details for the following functions & layers
#Signing profile details for function 'HelloWorld'
Signing Profile Name:
Signing Profile Owner Account ID (optional):
#Signing profile details for layer 'MyLayer', which is used by functions {'HelloWorld'}
Signing Profile Name:
Signing Profile Owner Account ID (optional):
```
## Bonnes pratiques
+ Lors de l'utilisation de `sam deploy`, la AWS SAM CLI déploie les artefacts de création de votre application situés dans le répertoire `.aws-sam`. Lorsque vous apportez des modifications aux fichiers d'origine de votre application, exécutez `sam build` pour mettre à jour le répertoire `.aws-sam` avant de procéder au déploiement.
+ Lorsque vous déployez une application pour la première fois, utilisez `sam deploy --guided` pour configurer les paramètres de déploiement. Pour les déploiements suivants, vous pouvez utiliser `sam deploy` pour déployer avec vos paramètres configurés.
## Options pour sam deploy
Les options suivantes sont couramment utilisées pour `sam deploy`. Pour obtenir la liste de toutes les options, consultez [sam deploy](sam-cli-command-reference-sam-deploy.md).
### Utiliser le flux interactif guidé pour déployer votre application
Utilisez l'option `--guided` pour configurer les paramètres de déploiement de votre application à travers un flux interactif. Voici un exemple :
```
$ sam deploy --guided
```
Les paramètres de déploiement de votre application sont enregistrés dans le fichier `samconfig.toml` de votre projet. Pour en savoir plus, veuillez consulter la section [Configuration des paramètres de projet](using-sam-cli-configure.md#using-sam-cli-configure-project).
## Résolution des problèmes
Pour résoudre le problème AWS SAMCLI, voir[Résolution des problèmes de la CLI AWS SAM](sam-cli-troubleshooting.md).
## Exemples
### Déployer une application Hello World qui contient une fonction Lambda packagée sous la forme d'une archive de fichier .zip
Pour un exemple, consultez [Étape 3 : Déployez votre application sur AWS Cloud](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-deploy) dans le didacticiel de l'application Hello World.
### Déployer une application Hello World qui contient une fonction Lambda packagée en tant qu'image de conteneur
Tout d'abord, nous l'utilisons `sam init` pour créer notre application Hello World. Au cours du flux interactif, nous sélectionnons l'exécution `Python3.9` et le type de package `Image`.
```
$ 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
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
1 - aot.dotnet7 (provided.al2)
...
15 - nodejs12.x
16 - python3.9
17 - python3.8
...
Runtime: 16
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 pip.
We will proceed copying the template using pip.
...
Project name [sam-app]: ENTER
-----------------------
Generating application:
-----------------------
Name: sam-app
Base Image: amazon/python3.9-base
Architectures: x86_64
Dependency Manager: pip
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app/README.md
...
```
Ensuite, nous `cd` vers le répertoire racine de notre projet et exécutons `sam build`. La CLI AWS SAM crée notre fonction Lambda localement en utilisant Docker.
```
sam-app $ sam build
Building codeuri: /Users/.../sam-app runtime: None metadata: {'Dockerfile': 'Dockerfile', 'DockerContext': '/Users/.../sam-app/hello_world', 'DockerTag': 'python3.9-v1'} architecture: x86_64 functions: HelloWorldFunction
Building image for HelloWorldFunction function
Setting DockerBuildArgs: {} for HelloWorldFunction function
Step 1/5 : FROM public.ecr.aws/lambda/python:3.9
---> 0a5e3da309aa
Step 2/5 : COPY requirements.txt ./
---> abc4e82e85f9
Step 3/5 : RUN python3.9 -m pip install -r requirements.txt -t .
---> [Warning] The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) and no specific platform was requested
---> Running in 43845e7aa22d
Collecting requests
Downloading requests-2.28.2-py3-none-any.whl (62 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 62.8/62.8 KB 829.5 kB/s eta 0:00:00
Collecting idna<4,>=2.5
Downloading idna-3.4-py3-none-any.whl (61 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 61.5/61.5 KB 2.4 MB/s eta 0:00:00
Collecting charset-normalizer<4,>=2
Downloading charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (199 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 199.2/199.2 KB 2.1 MB/s eta 0:00:00
Collecting certifi>=2017.4.17
Downloading certifi-2022.12.7-py3-none-any.whl (155 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 155.3/155.3 KB 10.2 MB/s eta 0:00:00
Collecting urllib3<1.27,>=1.21.1
Downloading urllib3-1.26.15-py2.py3-none-any.whl (140 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 140.9/140.9 KB 9.1 MB/s eta 0:00:00
Installing collected packages: urllib3, idna, charset-normalizer, certifi, requests
Successfully installed certifi-2022.12.7 charset-normalizer-3.1.0 idna-3.4 requests-2.28.2 urllib3-1.26.15
Removing intermediate container 43845e7aa22d
---> cab8ace899ce
Step 4/5 : COPY app.py ./
---> 4146f3cd69f2
Step 5/5 : CMD ["app.lambda_handler"]
---> [Warning] The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) and no specific platform was requested
---> Running in f4131ddffb31
Removing intermediate container f4131ddffb31
---> d2f5180b2154
Successfully built d2f5180b2154
Successfully tagged helloworldfunction:python3.9-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
```
Ensuite, nous exécutons `sam deploy --guided` pour déployer notre application. La CLI AWS SAM nous guide dans la configuration de nos paramètres de déploiement. Ensuite, AWS SAMCLI déploie notre application dans le AWS Cloud.
```
sam-app $ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [sam-app]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: ENTER
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
Looking for resources needed for deployment:
Managed S3 bucket: aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
A different default S3 bucket can be set in samconfig.toml and auto resolution of buckets turned off by setting resolve_s3=False
Parameter "stack_name=sam-app" in [default.deploy.parameters] is defined as a global parameter [default.global.parameters].
This parameter will be only saved under [default.global.parameters] in /Users/.../sam-app/samconfig.toml.
Saved arguments to config file
Running 'sam deploy' for future deployments will use the parameters saved above.
The above parameters can be changed by modifying samconfig.toml
Learn more about samconfig.toml syntax at
https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html
e95fc5e75742: Pushed
d8df51e7bdd7: Pushed
b1d0d7e0b34a: Pushed
0071317b94d8: Pushed
d98f98baf147: Pushed
2d244e0816c6: Pushed
eb2eeb1ebe42: Pushed
a5ca065a3279: Pushed
fe9e144829c9: Pushed
helloworldfunction-d2f5180b2154-python3.9-v1: digest: sha256:cceb71401b47dc3007a7a1e1f2e0baf162999e0e6841d15954745ecc0c447533 size: 2206
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment image repository :
{
"HelloWorldFunction": "012345678910.dkr.ecr.us-west-2.amazonaws.com/samapp7427b055/helloworldfunction19d43fc4repo"
}
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
HelloWorldFunction may not have authorization defined.
Uploading to sam-app/682ad27c7cf7a17c7f77a1688b0844f2.template 1328 / 1328 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
-------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
-------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A
oWorldPermissionProd n
+ Add HelloWorldFunctionRole AWS::IAM::Role N/A
+ Add HelloWorldFunction AWS::Lambda::Function N/A
+ Add ServerlessRestApiDeplo AWS::ApiGateway::Deplo N/A
yment47fc2d5f9d yment
+ Add ServerlessRestApiProdS AWS::ApiGateway::Stage N/A
tage
+ Add ServerlessRestApi AWS::ApiGateway::RestA N/A
pi
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680634124/0ffd4faf-2e2b-487e-b9e0-9116e8299ac4
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-04 08:49:15 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
-------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
-------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::CloudFormation::S sam-app User Initiated
tack
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
Initiated
CREATE_COMPLETE AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction Resource creation
Initiated
CREATE_COMPLETE AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi Resource creation
pi Initiated
CREATE_COMPLETE AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell Resource creation
n oWorldPermissionProd Initiated
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo Resource creation
yment yment47fc2d5f9d Initiated
CREATE_COMPLETE AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS Resource creation
tage Initiated
CREATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_COMPLETE AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_COMPLETE AWS::CloudFormation::S sam-app -
tack
-------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-JFML1JOKHJ71
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://endlwiqqod.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-
kyg6Y2iNRUPg
-------------------------------------------------------------------------------------------------
Successfully created/updated stack - sam-app in us-west-2
```
## En savoir plus
Pour en savoir plus sur l'utilisation de AWS SAMCLI `sam deploy` cette commande, consultez les rubriques suivantes :
+ **[L' AWS SAM atelier complet : Module 3 - Déploiement manuel](https://s12d.com/sam-ws-en-manual-deploy)** — Découvrez comment créer, empaqueter et déployer une application sans serveur à l'aide du AWS SAMCLI.
# Options pour déployer votre application avec AWS SAM
Avec AWS SAM, vous pouvez déployer votre application manuellement et automatiser les déploiements. Utilisez le AWS SAMCLI pour déployer manuellement votre application. Pour automatiser le déploiement, utilisez des pipelines et un système d'intégration et de déploiement continus (CI/CD). Les rubriques de cette section fournissent des informations sur les deux approches.
**Topics**
+ [Comment utiliser le AWS SAMCLI pour déployer manuellement](#serverless-sam-cli-using-package-and-deploy)
+ [Déployez avec CI/CD des systèmes et des pipelines](#serverless-deploying-ci-cd)
+ [Déploiements graduels](#serverless-deploying-gradual)
+ [Résolution de problèmes de déploiement à l'aide de la CLI AWS SAM](#serverless-deploying-troubleshooting)
+ [En savoir plus](#serverless-sam-cli-using-invoke-learn)
## Comment utiliser le AWS SAMCLI pour déployer manuellement
Après avoir développé et testé votre application sans serveur localement, vous pouvez déployer votre application à l'aide de la commande **[sam deploy](sam-cli-command-reference-sam-deploy.md)**.
Pour vous AWS SAM guider tout au long du déploiement à l'aide d'instructions, spécifiez le **--guided** drapeau. Lorsque vous spécifiez cet indicateur, la commande **sam deploy** compresse vos artefacts d'application, les télécharge soit sur Amazon Simple Storage Service (Amazon S3) (pour les archives de fichiers .zip), soit sur Amazon Elastic Container Registry (Amazon ECR) (pour les images de conteneur). La commande déploie ensuite votre application dans le AWS Cloud.
**Exemple :**
```
# Deploy an application using prompts:
sam deploy --guided
```
## Déployez avec CI/CD des systèmes et des pipelines
AWS SAM vous aide à automatiser le déploiement à l'aide de pipelines et d'un système d'intégration et de déploiement continus (CI/CD). AWS SAM peut être utilisé pour créer des pipelines et simplifier CI/CD les tâches des applications sans serveur. Plusieurs CI/CD systèmes prennent en charge la AWS SAM création d'images de conteneurs et fournissent AWS SAM également un ensemble de modèles de pipeline par défaut pour plusieurs CI/CD systèmes qui encapsulent les meilleures pratiques AWS de déploiement.
Pour de plus amples informations, veuillez consulter [Utilisation CI/CD de systèmes et de pipelines pour déployer avec AWS SAM](deploying-cicd-overview.md).
## Déploiements graduels
Si vous souhaitez déployer votre AWS SAM application progressivement plutôt qu'en une seule fois, vous pouvez spécifier les configurations de déploiement qui AWS CodeDeploy fournissent. Pour plus d'informations, consultez la section [Utilisation des configurations de déploiement CodeDeploy dans](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations.html) le *Guide de AWS CodeDeploy l'utilisateur*.
Pour plus d'informations sur la configuration de votre AWS SAM application pour un déploiement progressif, consultez[Déploiement progressif d'applications sans serveur avec AWS SAM](automating-updates-to-serverless-apps.md).
## Résolution de problèmes de déploiement à l'aide de la CLI AWS SAM
### Erreur CLI AWS SAM : « Contraintes de sécurité non satisfaites »
Lors de l'exécution de **sam deploy --guided**, vous devrez répondre à la question `HelloWorldFunction may not have authorization defined, Is this okay? [y/N]`. Si vous répondez à cette question par non **N** (réponse par défaut), vous voyez apparaître l'erreur suivante :
```
Error: Security Constraints Not Satisfied
```
L'invite vous informe que l'application que vous êtes sur le point de déployer peut comporter une API Amazon API Gateway configurée sans autorisation. En répondant **N** à cette question, vous dites que ce n'est pas OK.
Pour résoudre le problème, vous disposez des options suivantes :
+ Configurez votre application avec l'autorisation. Pour plus d'informations sur la configuration de l'autorisation, consultez [Contrôlez l'accès aux API avec votre AWS SAM modèle](serverless-controlling-access-to-apis.md).
+ Répondez à cette question par **Y** pour indiquer que vous êtes d'accord avec le déploiement d'une application sur laquelle une API API Gateway est configurée sans autorisation.
## En savoir plus
Pour des exemples pratiques de déploiement d'applications sans serveur, consultez le document suivant tiré de *The Complete AWS SAM Workshop* :
+ [Module 3 - Déploiement manuel](https://s12d.com/sam-ws-en-manual-deploy) — Découvrez comment créer, empaqueter et déployer une application sans serveur à l'aide du AWS SAMCLI.
+ [Module 4 – CI/CD](https://s12d.com/sam-ws-en-cicd-deploy) : découvrez comment automatiser les phases de création, de package et de déploiement en créant un pipeline d'*intégration et de livraison continues (CI/CD)*.
# Utilisation CI/CD de systèmes et de pipelines pour déployer avec AWS SAM
AWS SAM aide les entreprises à créer des pipelines pour leurs CI/CD systèmes préférés, afin qu'elles puissent en tirer parti CI/CD avec un minimum d'efforts, tels que l'accélération de la fréquence des déploiements, la réduction des délais de modification et la réduction des erreurs de déploiement.
AWS SAM simplifie CI/CD les tâches des applications sans serveur à l'aide de la création d'images de conteneur. Les images AWS SAM fournies incluent les outils AWS SAMCLI et les outils de génération pour un certain nombre d'environnements d' AWS Lambda exécution pris en charge. Cela facilite la création et le package d'applications sans serveur à l'aide du AWS SAMCLI. Ces images évitent également aux équipes de créer et de gérer leurs propres images pour les CI/CD systèmes. Pour plus d'informations sur la AWS SAM création d'images de conteneurs, consultez[Référentiels d'images pour AWS SAM](serverless-image-repositories.md).
Plusieurs CI/CD systèmes prennent en charge la AWS SAM création d'images de conteneurs. CI/CD Le système à utiliser dépend de plusieurs facteurs. Il s'agit notamment de savoir si votre application utilise une seule ou plusieurs exécutions, ou si vous souhaitez créer votre application dans une image de conteneur ou directement sur une machine hôte, une machine virtuelle (VM) ou un hôte de matériel nu.
AWS SAM fournit également un ensemble de modèles de pipeline par défaut pour plusieurs CI/CD systèmes qui encapsulent les meilleures pratiques AWS de déploiement. Ces modèles de pipeline par défaut utilisent des formats de configuration de JSON/YAML pipeline standard, et les meilleures pratiques intégrées permettent d'effectuer des déploiements multicomptes et multirégions, et de vérifier que les pipelines ne peuvent pas apporter de modifications involontaires à l'infrastructure.
Vous disposez de deux options principales AWS SAM pour déployer vos applications sans serveur : 1) Modifier la configuration de votre pipeline existante pour utiliser des AWS SAMCLI commandes, ou 2) Générer un exemple de configuration de CI/CD pipeline que vous pouvez utiliser comme point de départ pour votre propre application.
**Topics**
+ [Qu'est-ce qu'un pipeline ?](#deploying-whatis-pipeline)
+ [Comment AWS SAM télécharge les fichiers locaux lors du déploiement](deploy-upload-local-files.md)
+ [Générez un CI/CD pipeline de démarrage avec AWS SAM](serverless-generating-example-ci-cd.md)
+ [Comment personnaliser les pipelines de démarrage avec AWS SAM](serverless-customizing-starter-pipelines.md)
+ [Automatisez le déploiement de votre AWS SAM application](serverless-deploying-modify-pipeline.md)
+ [Comment utiliser l'authentification OIDC avec les pipelines AWS SAM](deploying-with-oidc.md)
## Qu'est-ce qu'un pipeline ?
Un pipeline est une séquence automatisée d'étapes effectuées pour publier une nouvelle version d'une application. [Vous pouvez utiliser de nombreux CI/CD systèmes courants pour déployer vos applications, notamment [Jenkins [AWS CodePipeline](https://aws.amazon.com/codepipeline)](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/) et Actions. AWS SAM GitHub](https://github.com/features/actions)
Les modèles de pipeline incluent les meilleures pratiques de AWS déploiement pour faciliter les déploiements multicomptes et multirégions. AWS les environnements tels que le développement et la production existent généralement dans AWS des comptes différents. Cela permet aux équipes de développement de configurer des pipelines de déploiement sécurisés, sans apporter de modifications involontaires à l'infrastructure.
Vous pouvez également fournir vos propres modèles de pipeline personnalisés pour aider à standardiser les pipelines au sein des équipes de développement.
# Comment AWS SAM télécharge les fichiers locaux lors du déploiement
Lorsque vous déployez votre application sur le AWS Cloud, AWS CloudFormation vos fichiers locaux doivent d'abord être téléchargés vers un AWS service accessible, tel qu'Amazon Simple Storage Service (Amazon S3). Cela inclut les fichiers locaux auxquels votre AWS SAM modèle fait référence. Pour répondre à cette exigence, AWS SAMCLI procédez comme suit lorsque vous utilisez la `sam package` commande `sam deploy` ou :
1. Télécharge automatiquement vos fichiers locaux vers un AWS service accessible.
1. Met automatiquement à jour votre modèle d'application pour faire référence au nouveau chemin de fichier.
**Topics**
+ [Démo : utilisation de la CLI AWS SAM pour charger le code d'une fonction Lambda](#deploy-upload-local-files-demo)
+ [Cas d’utilisation pris en charge](#deploy-upload-local-files-use)
+ [En savoir plus](#deploy-upload-local-files-learn)
## Démo : utilisation de la CLI AWS SAM pour charger le code d'une fonction Lambda
Dans cette démo, nous initialisons l'exemple d'application Hello World en utilisant un type de package .zip pour notre fonction Lambda. Nous utilisons la CLI AWS SAM pour charger automatiquement notre code de fonction Lambda dans Amazon S3 et référencer son nouveau chemin dans notre modèle d'application.
Tout d'abord, nous exécutons `sam init` pour initialiser notre application Hello World.
```
$ 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
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: y
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]: demo
-----------------------
Generating application:
-----------------------
Name: demo
Runtime: python3.9
Architectures: x86_64
Dependency Manager: pip
Application Template: hello-world
Output Directory: .
Configuration file: demo/samconfig.toml
...
```
Le code de notre fonction Lambda est organisé dans le sous-répertoire `hello_world` de notre projet.
```
demo
├── README.md
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── template.yaml
└── tests
```
Dans notre AWS SAM modèle, nous référençons le chemin local vers notre code de fonction Lambda à l'aide de la `CodeUri` propriété.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.9
...
```
Ensuite, nous exécutons `sam build` pour créer notre application et préparer son déploiement.
```
$ sam build
Starting Build use cache
Manifest file is changed (new hash: 3298f13049d19cffaa37ca931dd4d421) or dependency folder (.aws-sam/deps/7896875f-9bcc-4350-8adb-2c1d543627a1) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../demo/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Running PythonPipBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
...
```
Ensuite, nous exécutons `sam deploy --guided` pour déployer notre application.
```
$ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [demo]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: n
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
Looking for resources needed for deployment:
...
Saved arguments to config file
Running 'sam deploy' for future deployments will use the parameters saved above.
The above parameters can be changed by modifying samconfig.toml
Learn more about samconfig.toml syntax at
https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html
File with same data already exists at demo/da3c598813f1c2151579b73ad788cac8, skipping upload
Deploying with following values
===============================
Stack name : demo
Region : us-west-2
Confirm changeset : False
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
...
Waiting for changeset to be created..
CloudFormation stack changeset
-------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
-------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A
oWorldPermissionProd n
+ Add HelloWorldFunctionRole AWS::IAM::Role N/A
...
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680906292/1164338d-72e7-4593-a372-f2b3e67f542f
2023-04-07 12:24:58 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
-------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
-------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
Initiated
...
-------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/demo-HelloWorldFunctionRole-VQ4CU7UY7S2K
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://satnon55e9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:demo-
HelloWorldFunction-G14inKTmSQvK
-------------------------------------------------------------------------------------------------
Successfully created/updated stack - demo in us-west-2
```
Lors du déploiement, la CLI AWS SAM charge automatiquement notre code de fonction Lambda dans Amazon S3 et met à jour notre modèle. Notre modèle modifié dans la CloudFormation console reflète le chemin du compartiment Amazon S3.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: s3://aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr/demo/da3c598813f1c2151579b73ad788cac8
Handler: app.lambda_handler
...
```
## Cas d’utilisation pris en charge
Ils AWS SAMCLI peuvent automatiquement faciliter ce processus pour un certain nombre de types de fichiers, de types de CloudFormation ressources et de CloudFormation macros.
### Types de fichiers
Les fichiers d'application et les images Docker sont pris en charge.
### CloudFormation types de ressources
Vous trouverez ci-dessous une liste des types de ressources pris en charge et de leurs propriétés :
| Ressource | Propriétés |
| --- | --- |
| AWS::ApiGateway::RestApi | BodyS3Location |
| AWS::ApiGatewayV2::Api | BodyS3Location |
| AWS::AppSync:FunctionConfiguration | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` |
| AWS::AppSync::GraphQLSchema | DefinitionS3Location |
| AWS::AppSync::Resolver | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` |
| AWS::CloudFormation::ModuleVersion | ModulePackage |
| AWS::CloudFormation::ResourceVersion | SchemaHandlerPackage |
| AWS::ECR::Repository | RepositoryName |
| AWS::ElasticBeanstalk::ApplicationVersion | SourceBundle |
| AWS::Glue::Job | Command.ScriptLocation |
| AWS::Lambda::Function | `Code` `Code.ImageUri` |
| AWS::Lambda::LayerVersion | Content |
| AWS::Serverless::Api | DefinitionUri |
| AWS::Serverless::Function | `CodeUri` `ImageUri` |
| AWS::Serverless::GraphQLApi | `SchemaUri` `Function.CodeUri` `Resolver.CodeUri` |
| AWS::Serverless::HttpApi | DefinitionUri |
| AWS::Serverless::LayerVersion | ContentUri |
| AWS::Serverless::StateMachine | DefinitionUri |
| AWS::StepFunctions::StateMachine | DefinitionS3Location |
### CloudFormation macros
Les fichiers référencés à l'aide de la macro `AWS::Include` transform sont pris en charge.
## En savoir plus
Pour en savoir plus sur la `AWS::Include` transformation, voir [ AWS::Include transformation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html) dans le *guide de AWS CloudFormation l'utilisateur*.
Pour voir un exemple d'utilisation de la `AWS::Include` transformation dans un AWS SAM modèle, consultez le modèle [API Gateway HTTP API to SQS](https://serverlessland.com/patterns/apigw-sqs) sur *Serverless Land*.
# Générez un CI/CD pipeline de démarrage avec AWS SAM
Lorsque vous êtes prêt à automatiser le déploiement, vous pouvez utiliser l'un des modèles AWS SAM de pipeline de démarrage pour générer un pipeline de déploiement pour le CI/CD système que vous choisissez d'utiliser. Votre pipeline de déploiement est ce que vous configurez et utilisez pour automatiser le déploiement de votre application sans serveur. Un modèle de pipeline de démarrage est préconfiguré pour vous aider à configurer rapidement votre pipeline de déploiement pour votre application sans serveur.
Avec un modèle de pipeline de démarrage, vous pouvez générer des pipelines en quelques minutes à l'aide de la [sam pipeline init](sam-cli-command-reference-sam-pipeline-init.md) commande.
Les modèles de pipeline de démarrage utilisent la JSON/YAML syntaxe familière du CI/CD système et intègrent les meilleures pratiques, telles que la gestion des artefacts sur plusieurs comptes et régions, et l'utilisation du minimum d'autorisations requises pour déployer l'application. [Actuellement, la AWS SAM CLI prend en charge la génération de configurations de CI/CD pipeline de démarrage pour les [AWS CodePipeline](https://aws.amazon.com/codepipeline)pipelines [Jenkins](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/), [GitHub Actions](https://github.com/features/actions) et Bitbucket.](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/)
Voici les tâches de haut niveau que vous devez effectuer pour générer une configuration de pipeline de démarrage :
1. **Création de ressources d'infrastructure** : votre pipeline nécessite certaines AWS ressources, par exemple l'utilisateur IAM et les rôles dotés des autorisations nécessaires, un compartiment Amazon S3 et éventuellement un référentiel Amazon ECR.
1. **Connectez votre dépôt Git à votre CI/CD système** : votre CI/CD système doit savoir quel dépôt Git déclenchera l'exécution du pipeline. Notez que cette étape peut ne pas être nécessaire, selon la combinaison du référentiel Git et CI/CD du système que vous utilisez.
1. **Générez une configuration de pipeline** : cette étape génère une configuration de pipeline de démarrage qui inclut deux étapes de déploiement.
1. **Validez la configuration de votre pipeline dans votre dépôt Git** : cette étape est nécessaire pour s'assurer que votre CI/CD système est au courant de la configuration de votre pipeline et qu'elle sera exécutée lorsque les modifications seront validées.
Après avoir généré la configuration du pipeline de démarrage et l’avoir associée au référentiel Git, le pipeline se déclenche pour s’exécuter automatiquement chaque fois que quelqu’un associe une modification de code au référentiel.
L’ordre de ces étapes, ainsi que les détails de chaque étape, varient en fonction du système CI/CD :
+ Si vous utilisez AWS CodePipeline, consultez[Génération d'un pipeline de démarrage pour AWS CodePipeline in AWS SAM](serverless-generating-example-ci-cd-codepipeline.md).
+ Si vous utilisez Jenkins, GitLab CI/CD, GitHub Actions ou Bitbucket Pipelines, consultez. [AWS SAM À utiliser pour générer des pipelines de démarrage pour Jenkins, GitLab CI/CD, GitHub Actions, Bitbucket Pipelines](serverless-generating-example-ci-cd-others.md)
# Génération d'un pipeline de démarrage pour AWS CodePipeline in AWS SAM
Pour générer une configuration de pipeline de démarrage pour AWS CodePipeline, effectuez les tâches suivantes dans cet ordre :
1. Créer des ressources d’infrastructure
1. Générer la configuration du pipeline
1. Associer la configuration du pipeline au référentiel Git
1. Connectez votre dépôt Git à votre CI/CD système
**Note**
La procédure suivante utilise deux commandes de la CLI AWS SAM, `sam pipeline bootstrap` et `sam pipeline init`. La raison pour laquelle il existe deux commandes est de gérer le cas d'utilisation où les administrateurs (c'est-à-dire les utilisateurs qui ont besoin d'une autorisation pour configurer des AWS ressources d'infrastructure telles que les utilisateurs et les rôles IAM) ont plus d'autorisations que les développeurs (c'est-à-dire les utilisateurs qui ont juste besoin d'une autorisation pour configurer des pipelines individuels, mais pas les AWS ressources d'infrastructure requises).
## Étape 1 : créer des ressources d’infrastructure
Les pipelines utilisés AWS SAM nécessitent certaines AWS ressources, comme un utilisateur IAM et des rôles dotés des autorisations nécessaires, un compartiment Amazon S3 et éventuellement un référentiel Amazon ECR. Vous devez disposer d’un ensemble de ressources d’infrastructure pour chaque étape de déploiement du pipeline.
Vous pouvez exécuter la commande suivante pour vous aider avec cette configuration :
```
sam pipeline bootstrap
```
**Note**
Exécutez la commande précédente pour chaque étape de déploiement du pipeline.
## Étape 2 : générer la configuration du pipeline
Pour générer la configuration du pipeline, exécutez la commande suivante :
```
sam pipeline init
```
## Étape 3 : associer la configuration du pipeline au référentiel Git
Cette étape est nécessaire pour s'assurer que votre CI/CD système connaît la configuration de votre pipeline et qu'elle sera exécutée lorsque les modifications seront validées.
## Étape 4 : Connectez votre dépôt Git à votre CI/CD système
Car AWS CodePipeline vous pouvez désormais créer la connexion en exécutant la commande suivante :
```
sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --region
```
Si vous utilisez GitHub Bitbucket, après avoir exécuté la **sam deploy** commande précédemment, terminez la connexion en suivant les étapes décrites dans la section Pour établir **une connexion trouvée dans la rubrique Mettre à jour une connexion** [en attente](https://docs.aws.amazon.com/dtconsole/latest/userguide/connections-update.html) dans le *guide de l'utilisateur de la console Developer Tools*. En outre, stockez une copie `CodeStarConnectionArn` de la sortie de la **sam deploy** commande, car vous en aurez besoin si vous souhaitez l'utiliser AWS CodePipeline avec une autre branche que`main`.
## Configuration d’autres branches
Par défaut, AWS CodePipeline utilise la `main` branche avec AWS SAM. Si vous voulez utiliser une branche autre que `main`, vous devez exécuter à nouveau la commande **sam deploy**. Notez que selon le référentiel Git que vous utilisez, il se peut que vous deviez aussi fournir le `CodeStarConnectionArn` :
```
# For GitHub and Bitbucket
sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch= CodeStarConnectionArn="
# For AWS CodeCommit
sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch="
```
## En savoir plus
Pour un exemple pratique de configuration d'un CI/CD pipeline, voir [CI/CD with AWS CodePipeline](https://catalog.workshops.aws/complete-aws-sam/en-US/module-4-cicd) dans *The Complete AWS SAM * Workshop.
# AWS SAM À utiliser pour générer des pipelines de démarrage pour Jenkins, GitLab CI/CD, GitHub Actions, Bitbucket Pipelines
Pour générer une configuration de pipeline de démarrage pour les pipelines Jenkins, GitLab CI/CD, GitHub Actions ou Bitbucket, effectuez les tâches suivantes dans cet ordre :
1. Créer des ressources d’infrastructure
1. Connectez votre dépôt Git à votre CI/CD système
1. Créer des objets d’identification
1. Générer la configuration du pipeline
1. Associer la configuration du pipeline au référentiel Git
**Note**
La procédure suivante utilise deux commandes de la CLI AWS SAM, `sam pipeline bootstrap` et `sam pipeline init`. La raison pour laquelle il existe deux commandes est de gérer le cas d'utilisation où les administrateurs (c'est-à-dire les utilisateurs qui ont besoin d'une autorisation pour configurer des AWS ressources d'infrastructure telles que les utilisateurs et les rôles IAM) ont plus d'autorisations que les développeurs (c'est-à-dire les utilisateurs qui ont juste besoin d'une autorisation pour configurer des pipelines individuels, mais pas les AWS ressources d'infrastructure requises).
## Étape 1 : créer des ressources d’infrastructure
Les pipelines utilisés AWS SAM nécessitent certaines AWS ressources, comme un utilisateur IAM et des rôles dotés des autorisations nécessaires, un compartiment Amazon S3 et éventuellement un référentiel Amazon ECR. Vous devez disposer d’un ensemble de ressources d’infrastructure pour chaque étape de déploiement du pipeline.
Vous pouvez exécuter la commande suivante pour vous aider avec cette configuration :
```
sam pipeline bootstrap
```
**Note**
Exécutez la commande précédente pour chaque étape de déploiement du pipeline.
Vous devez saisir les AWS informations d'identification (identifiant de clé et clé secrète) des utilisateurs du pipeline pour chaque étape de déploiement de votre pipeline, car elles sont nécessaires pour les étapes suivantes.
## Étape 2 : Connectez votre dépôt Git à votre CI/CD système
La connexion de votre dépôt Git à votre CI/CD système est nécessaire pour que le CI/CD système puisse accéder au code source de votre application pour les builds et les déploiements.
**Note**
Vous pouvez ignorer cette étape si vous utilisez l’une des combinaisons suivantes, car la connexion est effectuée automatiquement :
GitHub Actions avec le GitHub référentiel
GitLab CI/CD avec dépôt GitLab
Bitbucket Pipelines avec un référentiel Bitbucket
Pour connecter votre dépôt Git à votre CI/CD système, effectuez l'une des opérations suivantes :
+ Si vous utilisez Jenkins, consultez « Ajout d’une source de branche » dans la section [Documentation Jenkins](https://www.jenkins.io/doc/book/pipeline/multibranch/).
+ Si vous utilisez GitLab CI/CD et un dépôt Git autre que celui-ci GitLab, consultez la [GitLabdocumentation relative](https://docs.gitlab.com/ee/ci/ci_cd_for_external_repos/) à la « connexion à un dépôt externe ».
## Étape 3 : créer des objets des informations d’identification
Chaque CI/CD système dispose de sa propre méthode de gestion des informations d'identification nécessaires pour accéder à votre dépôt Git. CI/CD
Pour créer les objets des informations d’identification nécessaires, effectuez l’une des opérations suivantes :
+ Si vous utilisez Jenkins, créez une seule « information d’identification » qui stocke à la fois l’identifiant de la clé et la clé secrète. Suivez les instructions du blog [Création d’un pipeline Jenkins avec AWS SAM](https://aws.amazon.com/blogs/compute/building-a-jenkins-pipeline-with-aws-sam/), dans la section **Configurer Jenkins**. Vous aurez besoin de l’« identifiant des informations d’identification » pour l’étape suivante.
+ Si vous utilisez le GitLab CI/CD, créez deux « variables protégées », une pour chaque identifiant de clé et une clé secrète. Suivez les instructions de la [GitLab documentation](https://docs.gitlab.com/ee/ci/variables/). Vous aurez besoin de deux « clés variables » pour l'étape suivante.
+ Si vous utilisez GitHub Actions, créez deux « secrets chiffrés », un pour chaque clé et une pour chaque clé secrète. Suivez les instructions de la [GitHubdocumentation](https://docs.github.com/en/actions/reference/encrypted-secrets). Vous aurez besoin de deux « noms secrets » pour l'étape suivante.
+ Si vous utilisez Bitbucket Pipelines, créez deux « variables sécurisées », une pour chaque identifiant de clé et clé secrète. Suivez les instructions de la section [Variables et secrets ](https://support.atlassian.com/bitbucket-cloud/docs/variables-and-secrets). Vous aurez besoin de deux « noms secrets » pour l’étape suivante.
## Étape 4 : générer la configuration du pipeline
Pour générer la configuration du pipeline, exécutez la commande suivante : Vous devez entrer l’objet des informations d’identification que vous avez créé à l’étape précédente :
```
sam pipeline init
```
## Étape 5 : associer la configuration du pipeline au référentiel Git
Cette étape est nécessaire pour s'assurer que votre CI/CD système connaît la configuration de votre pipeline et qu'elle sera exécutée lorsque les modifications seront validées.
## En savoir plus
Pour un exemple pratique de configuration d'un CI/CD pipeline en utilisantGitHub Actions, voir [CI/CD with GitHub](https://s12d.com/sam-ws-en-gh) dans *The Complete AWS SAM * Workshop.
# Comment personnaliser les pipelines de démarrage avec AWS SAM
En tant qu' CI/CD administrateur, vous souhaiterez peut-être personnaliser un modèle de pipeline de démarrage, ainsi que les instructions guidées associées, que les développeurs de votre organisation peuvent utiliser pour créer des configurations de pipeline.
La CLI AWS SAM utilise des modèles Cookiecutter lors de la création des modèles de démarrage. Pour en savoir plus sur les modèles cookie cutter, consultez [Cookiecutter](https://cookiecutter.readthedocs.io/en/latest/README.html).
Vous pouvez également personnaliser les invites que la CLI AWS SAM affiche aux utilisateurs lors de la création de configurations de pipeline à l'aide de la commande `sam pipeline init`. Pour personnaliser les invites des utilisateurs, procédez comme suit :
1. **Créez un fichier `questions.json`** – Le fichier `questions.json` doit être à la racine du référentiel du projet. Il s'agit du même répertoire que pour le fichier `cookiecutter.json`. Pour afficher le schéma du fichier `questions.json`, consultez [questions.json.schema](https://github.com/aws/aws-sam-cli/blob/2b831b29f76ac9c4e0cbcbd68b37f8f664e136d8/samcli/lib/pipeline/init/questions.json.schema). Pour afficher un exemple de fichier `questions.json`, consultez [questions.json](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/questions.json).
1. **Mapper les clés de questions avec les noms des coupeurs de cookies** – Chaque objet du fichier `questions.json` nécessite une clé qui correspond à un nom dans le modèle Cookiecutter. Cette correspondance de clé est la façon dont la CLI AWS SAM met en correspondance les réponses des utilisateurs au modèle de cookie cutter. Pour voir des exemples de correspondance de cette clé, consultez la section [Exemples de fichier](#serverless-customizing-starter-pipelines-example-files) plus loin dans cette rubrique.
1. **Créez un fichier `metadata.json`** – Déclarez le nombre d'étapes que le pipeline aura dans le fichier `metadata.json`. Le nombre d'étapes indique à la commande `sam pipeline init` le nombre d'étapes nécessaire pour fournir des informations ou, dans le cas de l'option `--bootstrap`, le nombre d'étapes pour lesquelles créer des ressources d'infrastructure. Pour accéder à un exemple de fichier `metadata.json`qui déclare un pipeline à deux étapes, consultez [metadata.json](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/metadata.json).
## Exemples de projets
Voici des exemples de projets, qui comprennent chacun un modèle Cookiecutter, un fichier `questions.json` et un fichier `metadata.json` :
+ Exemple de Jenkins : [Modèle de pipeline Jenkins en deux étapes](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/Jenkins/two-stage-pipeline-template)
+ CodePipeline exemple : [modèle de CodePipeline pipeline en deux étapes](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/AWS-CodePipeline/two-stage-pipeline-template)
## Exemples de fichier
L'ensemble de fichiers suivant montre comment les questions dans le fichier `questions.json` sont associées aux entrées du fichier de modèle Cookiecutter. Notez que ces exemples sont des extraits de fichiers, non des fichiers complets. Pour voir des exemples de fichiers complets, consultez la section [Exemples de projets](#serverless-customizing-starter-pipelines-example-projects) plus loin dans cette rubrique.
Exemple **`questions.json`** :
```
{
"questions": [{
"key": "intro",
"question": "\nThis template configures a pipeline that deploys a serverless application to a testing and a production stage.\n",
"kind": "info"
}, {
"key": "pipeline_user_jenkins_credential_id",
"question": "What is the Jenkins credential ID (via Jenkins plugin \"aws-credentials\") for pipeline user access key?",
"isRequired": true
}, {
"key": "sam_template",
"question": "What is the template file path?",
"default": "template.yaml"
}, {
...
```
Exemple **`cookiecutter.json`** :
```
{
"outputDir": "aws-sam-pipeline",
"pipeline_user_jenkins_credential_id": "",
"sam_template": "",
...
```
Exemple **`Jenkinsfile`** :
```
pipeline {
agent any
environment {
PIPELINE_USER_CREDENTIAL_ID = '{{cookiecutter.pipeline_user_jenkins_credential_id}}'
SAM_TEMPLATE = '{{cookiecutter.sam_template}}'
...
```
# Automatisez le déploiement de votre AWS SAM application
Dans AWS SAM, la manière dont vous automatisez le déploiement de votre AWS SAM application varie en fonction du CI/CD système que vous utilisez. C'est pourquoi les exemples présentés dans cette section vous montrent comment configurer différents CI/CD systèmes pour automatiser la création d'applications sans serveur dans une image de conteneur de AWS SAM génération. Ces images de conteneur de génération facilitent la création et le package d'applications sans serveur à l'aide du AWS SAMCLI.
Les procédures de votre CI/CD pipeline existant pour déployer des applications sans serveur AWS SAM sont légèrement différentes selon le CI/CD système que vous utilisez.
Les rubriques suivantes fournissent des exemples de configuration de votre CI/CD système pour créer des applications sans serveur dans une image de conteneur de AWS SAM génération :
**Topics**
+ [Utilisation AWS CodePipeline pour déployer avec AWS SAM](deploying-using-codepipeline.md)
+ [Utilisation de Bitbucket Pipelines pour déployer avec AWS SAM](deploying-using-bitbucket.md)
+ [Utiliser Jenkins pour déployer avec AWS SAM](deploying-using-jenkins.md)
+ [Utilisation de GitLab CI/CD pour déployer avec AWS SAM](deploying-using-gitlab.md)
+ [Utiliser GitHub des actions pour déployer avec AWS SAM](deploying-using-github.md)
# Utilisation AWS CodePipeline pour déployer avec AWS SAM
Pour configurer votre [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)pipeline afin d'automatiser la création et le déploiement de votre AWS SAM application, votre CloudFormation modèle et votre `buildspec.yml` fichier doivent contenir les lignes suivantes :
1. Référencer une image de conteneur de création avec l’exécution nécessaire à partir des images disponibles. L’exemple suivant utilise l’image de conteneur de création `public.ecr.aws/sam/build-nodejs20.x`.
1. Configurez les étapes du pipeline pour exécuter les commandes d'interface de ligne de AWS SAM commande (CLI) nécessaires. L'exemple suivant exécute deux commandes de la CLI AWS SAM : **sam build** et **sam deploy** (avec les options nécessaires).
Cet exemple suppose que vous avez déclaré toutes les fonctions et couches de votre fichier AWS SAM modèle avec`runtime: nodejs20.x`.
**CloudFormation extrait de modèle :**
```
CodeBuildProject:
Type: AWS::CodeBuild::Project
Properties:
Environment:
ComputeType: BUILD_GENERAL1_SMALL
Image: public.ecr.aws/sam/build-nodejs20.x
Type: LINUX_CONTAINER
...
```
**`buildspec.yml` extrait :**
```
version: 0.2
phases:
build:
commands:
- sam build
- sam deploy --no-confirm-changeset --no-fail-on-empty-changeset
```
Pour obtenir la liste des images de conteneur de création Amazon Elastic Container Registry (Amazon ECR) disponibles pour différentes exécutions, consultez [Référentiels d'images pour AWS SAM](serverless-image-repositories.md).
# Utilisation de Bitbucket Pipelines pour déployer avec AWS SAM
Pour configurer votre [pipeline Bitbucket](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/) afin d'automatiser la création et le déploiement de votre AWS SAM application, votre `bitbucket-pipelines.yml` fichier doit contenir les lignes suivantes :
1. Référencer une image de conteneur de création avec l’exécution nécessaire à partir des images disponibles. L’exemple suivant utilise l’image de conteneur de création `public.ecr.aws/sam/build-nodejs20.x`.
1. Configurez les étapes du pipeline pour exécuter les commandes d'interface de ligne de AWS SAM commande (CLI) nécessaires. L'exemple suivant exécute deux commandes de la CLI AWS SAM : **sam build** et **sam deploy** (avec les options nécessaires).
Cet exemple suppose que vous avez déclaré toutes les fonctions et couches de votre fichier AWS SAM modèle avec`runtime: nodejs20.x`.
```
image: public.ecr.aws/sam/build-nodejs20.x
pipelines:
branches:
main: # branch name
- step:
name: Build and Package
script:
- sam build
- sam deploy --no-confirm-changeset --no-fail-on-empty-changeset
```
Pour obtenir la liste des images de conteneur de construction Amazon Elastic Container Registry (Amazon ECR) disponibles pour différentes exécutions, consultez [Référentiels d'images pour AWS SAM](serverless-image-repositories.md).
# Utiliser Jenkins pour déployer avec AWS SAM
Pour configurer votre pipeline [Jenkins](https://www.jenkins.io/) afin d'automatiser la création et le déploiement de votre AWS SAM application, vous `Jenkinsfile` devez contenir des lignes qui effectuent les opérations suivantes :
1. Référencer une image de conteneur de création avec l’exécution nécessaire à partir des images disponibles. L’exemple suivant utilise l’image de conteneur de création `public.ecr.aws/sam/build-nodejs20.x`.
1. Configurez les étapes du pipeline pour exécuter les commandes d'interface de ligne de AWS SAM commande (CLI) nécessaires. L'exemple suivant exécute deux commandes de la CLI AWS SAM : **sam build** et **sam deploy** (avec les options nécessaires).
Cet exemple suppose que vous avez déclaré toutes les fonctions et couches de votre fichier AWS SAM modèle avec`runtime: nodejs20.x`.
```
pipeline {
agent { docker { image 'public.ecr.aws/sam/build-nodejs20.x' } }
stages {
stage('build') {
steps {
sh 'sam build'
sh 'sam deploy --no-confirm-changeset --no-fail-on-empty-changeset'
}
}
}
}
```
Pour obtenir la liste des images de conteneur de construction Amazon Elastic Container Registry (Amazon ECR) disponibles pour différentes exécutions, consultez [Référentiels d'images pour AWS SAM](serverless-image-repositories.md).
# Utilisation de GitLab CI/CD pour déployer avec AWS SAM
Pour configurer votre [GitLab](https://about.gitlab.com)pipeline afin d'automatiser la création et le déploiement de votre AWS SAM application, votre `gitlab-ci.yml` fichier doit contenir les lignes suivantes :
1. Référencer une image de conteneur de création avec l’exécution nécessaire à partir des images disponibles. L’exemple suivant utilise l’image de conteneur de création `public.ecr.aws/sam/build-nodejs20.x`.
1. Configurez les étapes du pipeline pour exécuter les commandes d'interface de ligne de AWS SAM commande (CLI) nécessaires. L'exemple suivant exécute deux commandes de la CLI AWS SAM : **sam build** et **sam deploy** (avec les options nécessaires).
Cet exemple suppose que vous avez déclaré toutes les fonctions et couches de votre fichier AWS SAM modèle avec`runtime: nodejs20.x`.
```
image: public.ecr.aws/sam/build-nodejs20.x
deploy:
script:
- sam build
- sam deploy --no-confirm-changeset --no-fail-on-empty-changeset
```
Pour obtenir la liste des images de conteneur de construction Amazon Elastic Container Registry (Amazon ECR) disponibles pour différentes exécutions, consultez [Référentiels d'images pour AWS SAM](serverless-image-repositories.md).
# Utiliser GitHub des actions pour déployer avec AWS SAM
Pour configurer votre [GitHub](https://github.com/)pipeline afin d'automatiser la création et le déploiement de votre AWS SAM application, vous devez d'abord installer l'interface de ligne de AWS SAM commande (CLI) sur votre hôte. Vous pouvez utiliser [GitHub les actions](https://github.com/features/actions) dans votre GitHub flux de travail pour faciliter cette configuration.
L'exemple de GitHub flux de travail suivant configure un hôte Ubuntu à l'aide d'une série d' GitHubactions, puis exécute des AWS SAMCLI commandes pour créer et déployer une AWS SAM application :
```
on:
push:
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-python@v3
- uses: aws-actions/setup-sam@v2
- uses: aws-actions/configure-aws-credentials@v1
with:
aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
aws-region: us-east-2
- run: sam build --use-container
- run: sam deploy --no-confirm-changeset --no-fail-on-empty-changeset
```
Pour obtenir la liste des images de conteneur de construction Amazon Elastic Container Registry (Amazon ECR) disponibles pour différentes exécutions, consultez [Référentiels d'images pour AWS SAM](serverless-image-repositories.md).
# Comment utiliser l'authentification OIDC avec les pipelines AWS SAM
AWS Serverless Application Model (AWS SAM) prend en charge l'authentification utilisateur OpenID Connect (OIDC) pour Bitbucket, GitHub Actions, ainsi que l'intégration GitLab continue et la livraison continue (comptes CI/CD) platforms. With this support, you can use authorized CI/CD utilisateurs) de l'une de ces plateformes pour gérer vos pipelines d'applications sans serveur. Dans le cas contraire, vous devrez créer et gérer plusieurs utilisateurs Gestion des identités et des accès AWS (IAM) pour contrôler l'accès aux AWS SAM pipelines.
## Configuration de l'OIDC avec un pipeline AWS SAM
Au cours du processus de `sam pipeline bootstrap` configuration, procédez comme suit pour configurer OIDC avec votre AWS SAM pipeline.
1. Lorsque vous êtes invité à choisir un fournisseur d'identité, sélectionnez **OIDC**.
1. Ensuite, sélectionnez un fournisseur OIDC pris en charge.
1. Saisissez l'URL du fournisseur OIDC, en commençant par **https://**.
**Note**
AWS SAM fait référence à cette URL lorsqu'elle génère le type de `AWS::IAM::OIDCProvider` ressource.
1. Suivez ensuite les instructions et entrez les informations de CI/CD plate-forme nécessaires pour accéder à la plate-forme sélectionnée. Ces informations varient selon la plateforme et peuvent inclure :
+ un ID client OIDC ;
+ le nom du référentiel ou l'identifiant universel unique (UUID) du code ;
+ le nom de groupe ou d'organisation associé au référentiel ;
+ GitHub organisation à laquelle appartient le référentiel de code.
+ GitHub nom du référentiel.
+ la branche à partir de laquelle les déploiements seront effectués.
1. AWS SAM affiche un résumé de la configuration OIDC saisie. Saisissez le numéro d'un paramètre pour le modifier, ou appuyez sur Enter pour continuer.
1. Lorsque vous êtes invité à confirmer la création des ressources nécessaires pour prendre en charge la connexion OIDC saisie, appuyez sur Y pour continuer.
AWS SAM génère une `AWS::IAM::OIDCProvider` AWS CloudFormation ressource avec la configuration fournie qui assume le rôle d'exécution du pipeline. Pour en savoir plus sur ce type de CloudFormation ressource, consultez [AWS : :IAM : : OIDCProvider](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-oidcprovider.html) dans le guide de l'*AWS CloudFormation utilisateur*.
**Note**
Si la ressource du fournisseur d'identité (IdP) existe déjà dans votre répertoire Compte AWS, AWS SAM référencez-la au lieu de créer une nouvelle ressource.
## Exemple
Voici un exemple de configuration d'OIDC avec un AWS SAM pipeline.
```
Select a permissions provider:
1 - IAM (default)
2 - OpenID Connect (OIDC)
Choice (1, 2): 2
Select an OIDC provider:
1 - GitHub Actions
2 - GitLab
3 - Bitbucket
Choice (1, 2, 3): 1
Enter the URL of the OIDC provider [https://token.actions.githubusercontent.com]:
Enter the OIDC client ID (sometimes called audience) [sts.amazonaws.com]:
Enter the GitHub organization that the code repository belongs to. If there is no organization enter your username instead: my-org
Enter GitHub repository name: testing
Enter the name of the branch that deployments will occur from [main]:
[3] Reference application build resources
Enter the pipeline execution role ARN if you have previously created one, or we will create one for you []:
Enter the CloudFormation execution role ARN if you have previously created one, or we will create one for you []:
Please enter the artifact bucket ARN for your Lambda function. If you do not have a bucket, we will create one for you []:
Does your application contain any IMAGE type Lambda functions? [y/N]:
[4] Summary
Below is the summary of the answers:
1 - Account: 123456
2 - Stage configuration name: dev
3 - Region: us-east-1
4 - OIDC identity provider URL: https://token.actions.githubusercontent.com
5 - OIDC client ID: sts.amazonaws.com
6 - GitHub organization: my-org
7 - GitHub repository: testing
8 - Deployment branch: main
9 - Pipeline execution role: [to be created]
10 - CloudFormation execution role: [to be created]
11 - Artifacts bucket: [to be created]
12 - ECR image repository: [skipped]
Press enter to confirm the values above, or select an item to edit the value:
This will create the following required resources for the 'dev' configuration:
- IAM OIDC Identity Provider
- Pipeline execution role
- CloudFormation execution role
- Artifact bucket
Should we proceed with the creation? [y/N]:
```
## En savoir plus
Pour plus d'informations sur l'utilisation de l'OIDC avec un AWS SAM pipeline, consultez[sam pipeline bootstrap](sam-cli-command-reference-sam-pipeline-bootstrap.md).
# Présentation de l'utilisation sam sync de la synchronisation avec AWS Cloud
La AWS Serverless Application Model commande Command Line Interface (AWS SAMCLI) `sam sync` fournit des options permettant de synchroniser rapidement les modifications apportées aux applications locales avec AWS Cloud. Utiliser `sam sync` lors du développement de vos applications pour :
1. Détectez et synchronisez automatiquement les modifications locales apportées au AWS Cloud.
1. Personnaliser les modifications locales qui sont synchronisées avec le AWS Cloud.
1. Préparer votre application dans le cloud pour les tests et la validation.
Avec `sam sync`, vous pouvez créer un flux de travail de développement rapide qui réduit le temps nécessaire à la synchronisation de vos modifications locales avec le cloud pour les tester et les valider.
**Note**
La commande `sam sync` est recommandée pour les environnements de développement. Pour les environnements de production, nous vous recommandons d'utiliser `sam deploy` ou de configurer un pipeline *d'intégration et de livraison continues (CI/CD)*. Pour en savoir plus, veuillez consulter la section [Déployez votre application et vos ressources avec AWS SAM](serverless-deploying.md).
La `sam sync` commande fait partie de AWS SAM Accelerate. *AWS SAM Accelerate*fournit des outils que vous pouvez utiliser pour accélérer l'expérience de développement et de test d'applications sans serveur dans le AWS Cloud.
**Topics**
+ [Détectez et synchronisez automatiquement les modifications locales apportées au AWS Cloud](#using-sam-cli-sync-auto)
+ [Personnalisez les modifications locales qui sont synchronisées avec AWS Cloud](#using-sam-cli-sync-customize)
+ [Préparer votre application dans le cloud pour les tests et la validation](#using-sam-cli-sync-test)
+ [Options pour la commande sam sync](#using-sam-cli-sync-options)
+ [Résolution des problèmes](#using-sam-cli-sync-troubleshooting)
+ [Exemples](#using-sam-cli-sync-examples)
+ [En savoir plus](#using-sam-cli-sync-learn)
## Détectez et synchronisez automatiquement les modifications locales apportées au AWS Cloud
Exécutez `sam sync` avec l'option `--watch` pour commencer à synchroniser votre application avec le AWS Cloud. Cela effectue les opérations suivantes :
1. **Créer votre application** : ce processus est similaire à l'utilisation de la commande `sam build`.
1. **Déployer votre application** : la CLI AWS SAM déploie votre application sur AWS CloudFormation en utilisant vos paramètres par défaut. Les valeurs par défaut suivantes sont utilisées :
1. AWS les informations d'identification et les paramètres de configuration généraux se trouvent dans votre dossier `.aws` utilisateur.
1. Les paramètres de déploiement de l'application se trouvent dans le fichier `samconfig.toml` de votre application.
Si les valeurs par défaut sont introuvables, la CLI AWS SAM vous en informera et quittera le processus de synchronisation.
1. **Surveiller les modifications locales** : la CLI AWS SAM continue de fonctionner et surveille les modifications locales apportées à votre application. C'est ce que permet l'option `--watch`.
Cette option peut être activée par défaut. Pour les valeurs par défaut, consultez le fichier `samconfig.toml` de votre application. Voici un exemple de fichier de :
```
...
[default.sync]
[default.sync.parameters]
watch = true
...
```
1. **Synchroniser les modifications locales avec le AWS Cloud** — Lorsque vous apportez des modifications locales, les AWS SAMCLI détecte et les synchronise AWS Cloud par le biais de la méthode la plus rapide disponible. Selon le type de modification, les éléments suivants peuvent se produire :
1. Si votre ressource mise à jour prend en charge le AWS service APIs, elle l' AWS SAMCLIutilisera pour déployer vos modifications. Il en résulte une synchronisation rapide pour mettre à jour votre ressource dans le AWS Cloud.
1. Si votre ressource mise à jour ne prend pas en charge le AWS service APIs, elle AWS SAMCLI effectuera un CloudFormation déploiement. Cela met à jour l'intégralité de votre application dans le AWS Cloud. Bien que cela ne soit pas aussi rapide, cela vous évite d'avoir à lancer manuellement un déploiement.
Étant donné que la `sam sync` commande met automatiquement à jour votre application dans le AWS Cloud, elle est recommandée uniquement pour les environnements de développement. Lorsque vous exécutez `sam sync`, il vous sera demandé de confirmer :
```
**The sync command should only be used against a development stack**.
Confirm that you are synchronizing a development stack.
Enter Y to proceed with the command, or enter N to cancel:
[Y/n]: ENTER
```
## Personnalisez les modifications locales qui sont synchronisées avec AWS Cloud
Fournissez des options pour personnaliser les modifications locales synchronisées avec le AWS Cloud. Cela peut accélérer le temps nécessaire pour que vos modifications locales soient visibles dans le cloud en vue d'être testées et validées.
Par exemple, offrez la `--code` possibilité de synchroniser uniquement les modifications de code, telles que le code de AWS Lambda fonction. Pendant le développement, si vous vous concentrez spécifiquement sur le code Lambda, vos modifications seront rapidement transférées dans le cloud pour les tester et les valider. Voici un exemple :
```
$ sam sync --code --watch
```
Pour synchroniser uniquement les modifications de code pour une fonction ou une couche Lambda spécifique, utilisez l'option `--resource-id`. Voici un exemple :
```
$ sam sync --code --resource-id HelloWorldFunction --resource-id HelloWorldLayer
```
## Préparer votre application dans le cloud pour les tests et la validation
La commande `sam sync` trouve automatiquement la méthode la plus rapide disponible pour mettre à jour votre application dans le AWS Cloud. Cela peut accélérer vos flux de travail de développement et de test dans le cloud. En utilisant le AWS service APIs, vous pouvez développer, synchroniser et tester rapidement les ressources prises en charge. Pour un exemple pratique, voir le [module 6 - AWS SAM Accélérer](https://s12d.com/sam-ws-en-accelerate) dans *The Complete AWS SAM Workshop*.
## Options pour la commande sam sync
Voici quelques-unes des principales options que vous pouvez utiliser pour modifier la commande `sam sync`. Pour obtenir la liste de toutes les options, consultez [sam sync](sam-cli-command-reference-sam-sync.md).
### Effectuez un CloudFormation déploiement ponctuel
Utilisez l'option `--no-watch` pour désactiver la synchronisation automatique. Voici un exemple :
```
$ sam sync --no-watch
```
Ils AWS SAMCLI effectueront un CloudFormation déploiement unique. Cette commande regroupe les actions effectuées par les commandes `sam build` et `sam deploy`.
### Ignorer le CloudFormation déploiement initial
Vous pouvez déterminer si un CloudFormation déploiement est requis à `sam sync` chaque exécution.
+ Indiquez `--no-skip-deploy-sync` d'exiger un CloudFormation déploiement à `sam sync` chaque exécution. Cela garantit que votre infrastructure locale est synchronisée avec CloudFormation, évitant ainsi toute dérive. L'utilisation de cette option ajoute du temps à votre flux de travail de développement et de test.
+ Indiquez `--skip-deploy-sync` pour rendre CloudFormation le déploiement facultatif. Il AWS SAMCLI comparera votre AWS SAM modèle local avec votre CloudFormation modèle déployé et ignorera le CloudFormation déploiement initial si aucune modification n'est détectée. Le fait de sauter CloudFormation le déploiement peut vous faire gagner du temps lors de la synchronisation des modifications locales apportées au. AWS Cloud
Si aucune modification n'est détectée, le CloudFormation déploiement AWS SAMCLI sera tout de même effectué dans les scénarios suivants :
+ Si 7 jours ou plus se sont écoulés depuis votre dernier CloudFormation déploiement.
+ Si un grand nombre de modifications du code de fonction Lambda sont détectées, le CloudFormation déploiement est la méthode la plus rapide pour mettre à jour votre application.
Voici un exemple :
```
$ sam sync --skip-deploy-sync
```
### Synchroniser une ressource à partir d'une pile imbriquée
**Pour synchroniser une ressource à partir d'une pile imbriquée**
1. Fournissez la pile racine en utilisant `--stack-name`.
1. Identifiez la ressource dans la pile imbriquée en utilisant le format suivant : `nestedStackId/resourceId`.
1. Fournissez la ressource dans la pile imbriquée en utilisant `--resource-id`.
Voici un exemple :
```
$ sam sync --code --stack-name sam-app --resource-id myNestedStack/HelloWorldFunction
```
Pour plus d'informations sur la création des applications imbriquées, consultez [Réutilisez le code et les ressources à l'aide d'applications imbriquées dans AWS SAM](serverless-sam-template-nested-applications.md).
### Spécifiez une CloudFormation pile spécifique à mettre à jour
Pour spécifier une CloudFormation pile spécifique à mettre à jour, indiquez l'`--stack-name`option. Voici un exemple :
```
$ sam sync --stack-name dev-sam-app
```
### 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`.
### Spécifiez les fichiers et les dossiers qui ne lanceront pas une synchronisation
Utilisez l’option `--watch-exclude` pour spécifier tout fichier ou dossier qui ne lancera pas une synchronisation lors de la mise à jour. Pour plus d’informations sur cette option, consultez `--watch-exclude`.
Voici un exemple qui exclut le fichier `package-lock.json` associé à notre fonction `HelloWorldFunction` :
```
$ sam sync --watch --watch-exclude HelloWorldFunction=package-lock.json
```
Lorsque cette commande est exécutée, le processus de synchronisation AWS SAM CLI sera lancé. Cela inclut les éléments suivants :
+ exécutez `sam build` pour créer vos fonctions et préparer votre application pour le déploiement.
+ exécutez `sam deploy` pour déployer votre application.
+ surveillez les changements apportées à votre application.
Lorsque nous modifierons le `package-lock.json` fichier, aucune synchronisation AWS SAM CLI ne sera lancée. Lorsqu'un autre fichier est mis à jour, une synchronisation AWS SAM CLI sera lancée, qui inclura le `package-lock.json` fichier.
Voici un exemple de spécification de fonction Lambda d’une pile enfant :
```
$ sam sync --watch --watch-exclude ChildStackA/MyFunction=database.sqlite3
```
## Résolution des problèmes
Pour résoudre le problème AWS SAMCLI, voir[Résolution des problèmes de la CLI AWS SAM](sam-cli-troubleshooting.md).
## Exemples
### Utiliser sam sync pour mettre à jour l'application Hello World
Dans cet exemple, nous commençons par initialiser l'exemple d'application Hello World. Pour en savoir plus sur cette application, consultez [Tutoriel : Déployer une application Hello World avec AWS SAM](serverless-getting-started-hello-world.md).
L'exécution de la commande `sam sync` lance le processus de création et de déploiement.
```
$ sam sync
The SAM CLI will use the AWS Lambda, Amazon API Gateway, and AWS StepFunctions APIs to upload your code without
performing a CloudFormation deployment. This will cause drift in your CloudFormation stack.
**The sync command should only be used against a development stack**.
Confirm that you are synchronizing a development stack.
Enter Y to proceed with the command, or enter N to cancel:
[Y/n]:
Queued infra sync. Waiting for in progress code syncs to complete...
Starting infra sync.
Manifest file is changed (new hash: 3298f13049d19cffaa37ca931dd4d421) or dependency folder (.aws-sam/deps/0663e6fe-a888-4efb-b908-e2344261e9c7) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../Demo/sync/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Build Succeeded
Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpx_5t4u3f.
Execute the following command to deploy the packaged template
sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpx_5t4u3f --stack-name
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
Parameter overrides : {}
Signing Profiles : null
Initiating deployment
=====================
2023-03-17 11:17:19 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 0.5 seconds)
---------------------------------------------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::CloudFormation::Stack sam-app Transformation succeeded
CREATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation Initiated
CREATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt Resource creation Initiated
ack
CREATE_COMPLETE AWS::IAM::Role HelloWorldFunctionRole -
CREATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction Resource creation Initiated
CREATE_COMPLETE AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::ApiGateway::RestApi ServerlessRestApi -
CREATE_IN_PROGRESS AWS::ApiGateway::RestApi ServerlessRestApi Resource creation Initiated
CREATE_COMPLETE AWS::ApiGateway::RestApi ServerlessRestApi -
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
CREATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
CREATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi Resource creation Initiated
ssionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d Resource creation Initiated
5f9d
CREATE_COMPLETE AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdStage -
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdStage Resource creation Initiated
CREATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdStage -
CREATE_COMPLETE AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
CREATE_COMPLETE AWS::CloudFormation::Stack sam-app -
---------------------------------------------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
----------------------------------------------------------------------------------------------------------------------------------------------
Outputs
----------------------------------------------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-BUFVMO2PJIYF
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://pcrx5gdaof.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-2PlN6TPTQoco
----------------------------------------------------------------------------------------------------------------------------------------------
Stack creation succeeded. Sync infra completed.
Infra sync completed.
CodeTrigger not created as CodeUri or DefinitionUri is missing for ServerlessRestApi.
```
Une fois le déploiement terminé, nous modifions le code `HelloWorldFunction`. AWS SAMCLIDétecte ce changement et synchronise notre application avec le AWS Cloud. Étant donné que AWS le service est AWS Lambda compatible APIs, une synchronisation rapide est effectuée.
```
Syncing Lambda Function HelloWorldFunction...
Manifest is not changed for (HelloWorldFunction), running incremental build
Building codeuri: /Users/.../Demo/sync/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CopySource
Finished syncing Lambda Function HelloWorldFunction.
```
Ensuite, nous modifions notre point de terminaison d'API dans le AWS SAM modèle de l'application. Nous modifions `/hello` pour `/helloworld`.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
...
Properties:
...
Events:
HelloWorld:
Type: Api
Properties:
Path: /helloworld
Method: get
```
Étant donné que la ressource Amazon API Gateway ne prend pas en charge l'API du AWS service, elle effectue AWS SAMCLI automatiquement un CloudFormation déploiement. Voici un exemple de résultat :
```
Queued infra sync. Waiting for in progress code syncs to complete...
Starting infra sync.
Manifest is not changed for (HelloWorldFunction), running incremental build
Building codeuri: /Users/.../Demo/sync/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CopySource
Build Succeeded
Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpuabo0jb9.
Execute the following command to deploy the packaged template
sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpuabo0jb9 --stack-name
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
Parameter overrides : {}
Signing Profiles : null
Initiating deployment
=====================
2023-03-17 14:41:18 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 0.5 seconds)
---------------------------------------------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------------------------------------------
UPDATE_IN_PROGRESS AWS::CloudFormation::Stack sam-app Transformation succeeded
UPDATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
UPDATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
UPDATE_IN_PROGRESS AWS::ApiGateway::RestApi ServerlessRestApi -
UPDATE_COMPLETE AWS::ApiGateway::RestApi ServerlessRestApi -
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment8cf30e -
d3cd
UPDATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi Requested update requires the
ssionProd creation of a new physical
resource; hence creating one.
UPDATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi Resource creation Initiated
ssionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment8cf30e Resource creation Initiated
d3cd
CREATE_COMPLETE AWS::ApiGateway::Deployment ServerlessRestApiDeployment8cf30e -
d3cd
UPDATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdStage -
UPDATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdStage -
UPDATE_COMPLETE AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
UPDATE_COMPLETE_CLEANUP_IN_PROGRE AWS::CloudFormation::Stack sam-app -
SS
DELETE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
DELETE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
DELETE_COMPLETE AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
UPDATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
DELETE_COMPLETE AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
UPDATE_COMPLETE AWS::CloudFormation::Stack sam-app -
---------------------------------------------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
----------------------------------------------------------------------------------------------------------------------------------------------
Outputs
----------------------------------------------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-BUFVMO2PJIYF
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://pcrx5gdaof.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-2PlN6TPTQoco
----------------------------------------------------------------------------------------------------------------------------------------------
Stack update succeeded. Sync infra completed.
Infra sync completed.
```
## En savoir plus
Pour obtenir une description de toutes les options `sam sync`, consulter [sam sync](sam-cli-command-reference-sam-sync.md).