Prérequis Étape 1 : initialisation de l'exemple d'application Hello World Étape 2 : créer votre application Étape 3 : Déployez votre application sur AWS Cloud Étape 4 : exécuter votre application Étape 5 : Interagissez avec votre fonction dans AWS Cloud Étape 6 : Modifiez et synchronisez votre application avec AWS Cloud Étape 7 : (Facultatif) testez votre application localement Étape 8 : Supprimez votre application du AWS Cloud Résolution des problèmes En savoir plus

Tutoriel : déploiement d'une application Hello World

Dans ce didacticiel, vous allez utiliser l'interface de ligne de AWS Serverless Application Model commande (AWS SAMCLI) pour effectuer les opérations suivantes :

Initialiser, créer et déployer un exemple d'application Hello World.
Apportez des modifications locales et synchronisez avec AWS CloudFormation.
Testez votre application dans le AWS Cloud.
Éventuellement effectuer des tests locaux sur votre hôte de développement.
Supprimer l'exemple d'application du AWS Cloud.

L'exemple d'application Hello World implémente une API backend de base. Elle regroupe les ressources suivantes :

Amazon API Gateway : point de terminaison d'API que vous utilisez pour appeler votre fonction.
AWS Lambda : fonction qui traite la requête HTTP API GET et renvoie un message hello world.
AWS Identity and Access Management Rôle (IAM) : fournit des autorisations permettant aux services d'interagir en toute sécurité.

Le diagramme suivant montre les composants de cette application :

Diagramme d'une fonction Lambda appelée lorsque vous envoyez une demande GET au point de terminaison API Gateway.

Rubriques

Prérequis
Étape 1 : initialisation de l'exemple d'application Hello World
Étape 2 : créer votre application
Étape 3 : Déployez votre application sur AWS Cloud
Étape 4 : exécuter votre application
Étape 5 : Interagissez avec votre fonction dans AWS Cloud
Étape 6 : Modifiez et synchronisez votre application avec AWS Cloud
Étape 7 : (Facultatif) testez votre application localement
Étape 8 : Supprimez votre application du AWS Cloud
Résolution des problèmes
En savoir plus

Prérequis

Vérifiez que vous avez effectué les opérations suivantes :

Étape 1 : initialisation de l'exemple d'application Hello World

Au cours de cette étape, vous allez utiliser la CLI AWS SAM pour créer un exemple de projet d'application Hello World sur votre ordinateur local.

Pour initialiser l'exemple d'application Hello World

Dans votre ligne de commande, exécutez la commande suivante à partir du répertoire de départ de votre choix :
```
$ sam init
```

La CLI AWS SAM vous guidera tout au long de l'initialisation d'une nouvelle application. Configurez ce qui suit :

Sélectionnez Modèles de démarrage rapide AWS pour choisir un modèle de départ.
Choisissez le modèle Hello World Example et téléchargez-le.
Utilisez l'exécution Python et le type de package zip.
Dans le cadre de ce didacticiel, désactivez le AWS X-Ray traçage. Pour en savoir plus, consultez Qu'est-ce que c'est AWS X-Ray ? dans le Guide AWS X-Ray du développeur.
Pour ce didacticiel, désactivez la surveillance avec Amazon CloudWatch Application Insights. Pour en savoir plus, consultez Amazon CloudWatch Application Insights dans le guide de CloudWatch l'utilisateur Amazon.
Pour ce didacticiel, désactivez la configuration de la journalisation structurée au format JSON sur vos fonctions Lambda.
Nommez votre application sam-app.

Pour utiliser le flux interactif de la CLI AWS SAM :

Les crochets ([ ]) indiquent les valeurs par défaut. Laissez la réponse vide pour sélectionner la valeur par défaut.
Saisissez y pour oui et n pour non.

Vous trouverez ci-dessous un exemple du flux interactif sam init :


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

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

Use the most popular runtime and package type? (Python and zip) [y/N]: 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
					
Would you like to set Structured Logging in JSON format on your Lambda functions?  [y/N]: ENTER

Project name [sam-app]: ENTER

AWS SAMCLITélécharge ensuite votre modèle de départ et crée la structure du répertoire du projet d'application sur votre machine locale. Voici un exemple de réponse générée par la CLI AWS SAM :

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

    -----------------------
    Generating application:
    -----------------------
    Name: sam-app
    Runtime: python3.9
    Architectures: x86_64
    Dependency Manager: pip
    Application Template: hello-world
    Output Directory: .
    Configuration file: sam-app/samconfig.toml

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


Commands you can use next
=========================
[*] Create pipeline: cd sam-app && sam pipeline init --bootstrap
[*] Validate SAM template: cd sam-app && sam validate
[*] Test Function in the Cloud: cd sam-app && sam sync --stack-name {stack-name} --watch

À partir de votre ligne de commande, accédez au répertoire sam-app que vous venez de créer. Voici un exemple de ce que la CLI AWS SAM a créé :
```
$ cd sam-app

$ tree

├── README.md
├── __init__.py
├── events
│   └── event.json
├── hello_world
│   ├── __init__.py
│   ├── app.py
│   └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
    ├── __init__.py
    ├── integration
    │   ├── __init__.py
    │   └── test_api_gateway.py
    ├── requirements.txt
    └── unit
        ├── __init__.py
        └── test_handler.py
        
6 directories, 14 files
```
Quelques fichiers importants à signaler :
- hello_world/app.py : contient le code de votre fonction Lambda.
- hello_world/requirements.txt : contient toutes les dépendances Python requises par votre fonction Lambda.
- samconfig.toml— Fichier de configuration de votre application qui stocke les paramètres par défaut utilisés par le AWS SAMCLI.
- template.yaml— Le AWS SAM modèle qui contient le code de l'infrastructure de votre application.

Vous disposez désormais d'une application sans serveur entièrement créée sur votre ordinateur local !

Étape 2 : créer votre application

Au cours de cette étape, vous utilisez la CLI AWS SAM pour créer votre application et préparer le déploiement. Lorsque vous créez, la CLI AWS SAM crée un répertoire .aws-sam et organise vos dépendances de fonctions, votre code de projet et vos fichiers de projet.

Pour créer votre application

Dans votre ligne de commande, à partir du répertoire du projet sam-app, exécutez ce qui suit :


$ sam build

Note

Si vous n'avez pas Python sur votre ordinateur local, utilisez la commande sam build --use-container à la place. La CLI AWS SAM créera un conteneur Docker qui inclut l'exécution et les dépendances de votre fonction. Cette commande nécessite Docker sur votre ordinateur local. Pour installer Docker, consultez Installation de Docker.

Voici un exemple de réponse générée par la CLI AWS SAM :


$ sam build
Starting Build use cache
Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../Demo/sam-tutorial1/sam-app/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

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

Voici un exemple abrégé du répertoire .aws-sam créé par la CLI AWS SAM :

.aws-sam
├── build
│   ├── HelloWorldFunction
│   │   ├── __init__.py
│   │   ├── app.py
│   │   └── requirements.txt
│   └── template.yaml
└── build.toml

Quelques fichiers importants à signaler :

build/HelloWorldFunction : contient le code de votre fonction Lambda et ses dépendances. La CLI AWS SAM crée un répertoire pour chaque fonction de votre application.
build/template.yaml— Contient une copie de votre AWS SAM modèle référencée par AWS CloudFormation lors du déploiement.
build.toml : le fichier de configuration qui stocke les valeurs de paramètres par défaut référencées par la CLI AWS SAM lors de la création et du déploiement de votre application.

Vous êtes maintenant prêt à déployer votre application sur le AWS Cloud.

Étape 3 : Déployez votre application sur AWS Cloud

Note

Cette étape nécessite la configuration AWS des informations d'identification. Pour plus d'informations, consultez Étape 5 : utilisez le AWS CLI pour configurer les AWS informations d'identification dans AWS SAM prérequis.

Au cours de cette étape, vous utilisez la CLI AWS SAM pour déployer votre application sur le AWS Cloud. Ils AWS SAMCLI effectueront les opérations suivantes :

Vous guide dans la configuration des paramètres de votre application pour le déploiement.
Charge les fichiers de votre application sur Amazon Simple Storage Service (Amazon S3).
Transformez votre AWS SAM modèle en AWS CloudFormation modèle. Il télécharge ensuite votre modèle sur le AWS CloudFormation service pour fournir vos AWS ressources.

Pour déployer votre application

Dans votre ligne de commande, à partir du répertoire du projet sam-app, exécutez ce qui suit :
```
$ sam deploy --guided
```
Suivez le flux interactif de la CLI AWS SAM pour configurer les paramètres de votre application. Configurez ce qui suit :
1. Le nom de la AWS CloudFormation pile — Une pile est un ensemble de AWS ressources que vous pouvez gérer comme une seule unité. Pour en savoir plus, consultez la section Utilisation des piles dans le Guide de l'utilisateur AWS CloudFormation .
2. Le Région AWSsur lequel déployer votre AWS CloudFormation stack. Pour de plus amples informations, consultez la section Points de terminaison AWS CloudFormation dans le Guide de l'utilisateur AWS CloudFormation .
3. Pour ce didacticiel, désactivez la confirmation des modifications avant le déploiement.
4. Autoriser la création de rôles IAM : cela permet de AWS SAM créer le rôle IAM nécessaire à l'interaction entre votre ressource API Gateway et votre ressource de fonction Lambda.
5. Pour ce didacticiel, désactivez l'option de désactivation de la restauration.
6. Autoriser HelloWorldFunction sans autorisation définie : ce message s'affiche car votre point de terminaison API Gateway est configuré pour être accessible au public, sans autorisation. Comme il s'agit de la configuration prévue pour votre application Hello World, autorisez la CLI AWS SAMà continuer. Pour plus d'informations sur la configuration de l'autorisation, consultez Contrôle de l'accès aux API de API Gateway.
7. Enregistrer les arguments dans le fichier de configuration : cela mettra à jour le fichier samconfig.toml de votre application avec vos préférences de déploiement.
8. Sélectionnez le nom du fichier de configuration par défaut.
9. Sélectionnez l'environnement de configuration par défaut.
Vous trouverez ci-dessous un exemple du résultat du flux interactif sam deploy --guided :
```
$ 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]: 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
```

AWS SAMCLIDéploie ensuite votre application en procédant comme suit :

La CLI AWS SAM crée un compartiment Amazon S3 et charge votre répertoire .aws-sam.
AWS SAMCLITransforme ensuite votre AWS SAM modèle AWS CloudFormation et le télécharge sur le AWS CloudFormation service.
AWS CloudFormation approvisionne vos ressources.

Pendant le déploiement, la CLI AWS SAM affiche votre progression. Voici un exemple de résultat :

Looking for resources needed for deployment:

    Managed S3 bucket: aws-sam-cli-managed-default-samclisourcebucket-1a4x26zbcdkqr
    A different default S3 bucket can be set in samconfig.toml

    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/.../Demo/sam-tutorial1/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

File with same data already exists at sam-app/da3c598813f1c2151579b73ad788cac8, skipping upload

    Deploying with following values
    ===============================
    Stack name                   : sam-app
    Region                       : us-west-2
    Confirm changeset            : False
    Disable rollback             : False
    Deployment s3 bucket         : aws-sam-cli-managed-default-samclisourcebucket-1a4x26zbcdkqr
    Capabilities                 : ["CAPABILITY_IAM"]
    Parameter overrides          : {}
    Signing Profiles             : {}

Initiating deployment
=====================

File with same data already exists at sam-app/2bebf67c79f6a743cc5312f6dfc1efee.template, skipping upload


Waiting for changeset to be created..

CloudFormation stack changeset
---------------------------------------------------------------------------------------------------------------------------------------------
Operation                           LogicalResourceId                   ResourceType                        Replacement
---------------------------------------------------------------------------------------------------------------------------------------------
* Modify                            HelloWorldFunction                  AWS::Lambda::Function               False
* Modify                            ServerlessRestApi                   AWS::ApiGateway::RestApi            False
- Delete                            AwsSamAutoDependencyLayerNestedSt   AWS::CloudFormation::Stack          N/A
                                    ack
---------------------------------------------------------------------------------------------------------------------------------------------


Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1678917603/22e05525-08f9-4c52-a2c4-f7f1fd055072


2023-03-15 12:00:16 - 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::Lambda::Function               HelloWorldFunction                  -
UPDATE_COMPLETE                     AWS::Lambda::Function               HelloWorldFunction                  -
UPDATE_COMPLETE_CLEANUP_IN_PROGRE   AWS::CloudFormation::Stack          sam-app                             -
SS
DELETE_IN_PROGRESS                  AWS::CloudFormation::Stack          AwsSamAutoDependencyLayerNestedSt   -
                                                                        ack
DELETE_COMPLETE                     AWS::CloudFormation::Stack          AwsSamAutoDependencyLayerNestedSt   -
                                                                        ack
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-15GLOUR9LMT1W

Key                 HelloWorldApi
Description         API Gateway endpoint URL for Prod stage for Hello World function
Value               https://<restapiid>.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-yQDNe17r9maD
----------------------------------------------------------------------------------------------------------------------------------------------


Successfully created/updated stack - sam-app in us-west-2

Votre application est désormais déployée et s'exécute dans le AWS Cloud !

Étape 4 : exécuter votre application

Au cours de cette étape, vous allez envoyer une requête GET à votre point de terminaison d'API et consulter le résultat de votre fonction Lambda.

Pour obtenir la valeur du point de terminaison de votre API

À partir des informations affichées par la CLI AWS SAMà l'étape précédente, localisez la section Outputs. Dans cette section, recherchez votre ressource HelloWorldApi pour trouver la valeur de votre point de terminaison HTTP. Voici un exemple de résultat :

----------------------------------------------------------------------------------------------------------------------------------------------
Outputs
----------------------------------------------------------------------------------------------------------------------------------------------
...
Key                 HelloWorldApi
Description         API Gateway endpoint URL for Prod stage for Hello World function
Value               https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/
...
----------------------------------------------------------------------------------------------------------------------------------------------

Vous pouvez également utiliser la commande sam list endpoints --output json pour obtenir ces informations. Voici un exemple de résultat :


$ sam list endpoints --output json
2023-03-15 12:39:19 Loading policies from IAM...
2023-03-15 12:39:25 Finished loading policies from IAM.
[
  {
    "LogicalResourceId": "HelloWorldFunction",
    "PhysicalResourceId": "sam-app-HelloWorldFunction-yQDNe17r9maD",
    "CloudEndpoint": "-",
    "Methods": "-"
  },
  {
    "LogicalResourceId": "ServerlessRestApi",
    "PhysicalResourceId": "ets1gv8lxi",
    "CloudEndpoint": [
      "https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod",
      "https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Stage"
    ],
    "Methods": [
      "/hello['get']"
    ]
  }
]

Pour appeler votre fonction

À l'aide de votre navigateur ou de la ligne de commande, envoyez une requête GET au point de terminaison de votre API. Voici un exemple d'utilisation de la commande curl :
```
$ curl https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/
{"message": "hello world"}
```

Étape 5 : Interagissez avec votre fonction dans AWS Cloud

Au cours de cette étape, vous utilisez la CLI AWS SAM pour invoquer votre fonction Lambda sur le AWS Cloud.

Pour invoquer votre fonction Lambda dans le cloud

Prenez note des fonctions LogicalResourceId que vous avez utilisées à l'étape précédente. Ça devrait être HelloWorldFunction.
Dans votre ligne de commande, à partir du répertoire du projet sam-app, exécutez ce qui suit :
```
$ sam remote invoke HelloWorldFunction --stack-name sam-app
```

AWS SAMCLIInvoque votre fonction dans le cloud et renvoie une réponse. Voici un exemple de résultat :


$ sam remote invoke HelloWorldFunction --stack-name sam-app

Invoking Lambda Function HelloWorldFunction                                       
START RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 Version: $LATEST
END RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9
REPORT RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9  Duration: 6.62 ms       Billed Duration: 7 ms     Memory Size: 128 MB     Max Memory Used: 67 MB  Init Duration: 164.06 ms
{"statusCode":200,"body":"{\"message\":\"hello world\"}"}%

Étape 6 : Modifiez et synchronisez votre application avec AWS Cloud

Au cours de cette étape, vous utilisez la AWS SAMCLI sam sync --watch commande pour synchroniser les modifications locales apportées au AWS Cloud.

Pour utiliser sam sync

Dans votre ligne de commande, à partir du répertoire du projet sam-app, exécutez ce qui suit :
```
$ sam sync --watch
```

La CLI AWS SAM vous invite à confirmer que vous synchronisez une pile de développement. Étant donné que la sam sync --watch commande déploie automatiquement les modifications locales AWS Cloud en temps réel, nous la recommandons uniquement pour les environnements de développement.

La CLI AWS SAM effectue un déploiement initial avant de commencer à surveiller les modifications locales. Voici un exemple de résultat :


$ sam sync --watch
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]: y
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/sam-tutorial1/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/tmpq3x9vh63.
Execute the following command to deploy the packaged template
sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpq3x9vh63 --stack-name <YOUR 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-samclisourcebucket-1a4x26zbcdkqr
    Capabilities                 : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
    Parameter overrides          : {}
    Signing Profiles             : null

Initiating deployment
=====================


2023-03-15 13:10:05 - 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
CREATE_IN_PROGRESS                  AWS::CloudFormation::Stack          AwsSamAutoDependencyLayerNestedSt   -
                                                                        ack
CREATE_IN_PROGRESS                  AWS::CloudFormation::Stack          AwsSamAutoDependencyLayerNestedSt   Resource creation Initiated
                                                                        ack
CREATE_COMPLETE                     AWS::CloudFormation::Stack          AwsSamAutoDependencyLayerNestedSt   -
                                                                        ack
UPDATE_IN_PROGRESS                  AWS::Lambda::Function               HelloWorldFunction                  -
UPDATE_COMPLETE                     AWS::Lambda::Function               HelloWorldFunction                  -
UPDATE_COMPLETE_CLEANUP_IN_PROGRE   AWS::CloudFormation::Stack          sam-app                             -
SS
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-15GLOUR9LMT1W

Key                 HelloWorldApi
Description         API Gateway endpoint URL for Prod stage for Hello World function
Value               https://ets1gv8lxi.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-yQDNe17r9maD
----------------------------------------------------------------------------------------------------------------------------------------------


Stack update succeeded. Sync infra completed.

Infra sync completed.
CodeTrigger not created as CodeUri or DefinitionUri is missing for ServerlessRestApi.

Ensuite, vous allez modifier le code de votre fonction Lambda. Le AWS SAMCLI détectera automatiquement ce changement et synchronisera votre application avec le AWS Cloud.

Pour modifier et synchroniser votre application

Dans l'IDE de votre choix, ouvrez le fichier sam-app/hello_world/app.py.

Remplacez le message et enregistrez le fichier. Voici un exemple :


import json
...
def lambda_handler(event, context):
    ...
    return {
        "statusCode": 200,
        "body": json.dumps({
            "message": "hello everyone!",
            ...
        }),
    }

AWS SAMCLIDétecte votre modification et synchronise votre application avec le AWS Cloud. Voici un exemple de résultat :

Syncing Lambda Function HelloWorldFunction...
Manifest is not changed for (HelloWorldFunction), running incremental build
Building codeuri: /Users/.../Demo/sam-tutorial1/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CopySource
Finished syncing Lambda Function HelloWorldFunction.

Pour vérifier votre modification, envoyez à nouveau une requête GET au point de terminaison de votre API.
```
$ curl https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/
{"message": "hello everyone!"}
```

Étape 7 : (Facultatif) testez votre application localement

Note

Cette étape est facultative car elle nécessite Docker sur votre ordinateur local.

Important

Pour utiliser la CLI AWS SAMà des fins de tests locaux, Docker doit être installé et configuré. Pour plus d’informations, consultez Installation de Docker.

Au cours de cette étape, vous devez utiliser la AWS SAMCLI sam local commande pour tester votre application localement. Pour ce faire, la CLI AWS SAM crée un environnement local à l'aide de Docker. Cet environnement local émule l'environnement d'exécution basé sur le cloud de votre fonction Lambda.

Vous effectuez les actions suivantes :

Créez un environnement local pour votre fonction Lambda et appelez-la.
Hébergez le point de terminaison de votre API HTTP en local et utilisez-le pour appeler votre fonction Lambda.

Pour appeler votre fonction Lambda localement

Dans votre ligne de commande, à partir du répertoire du projet sam-app, exécutez ce qui suit :
```
$ sam local invoke
```

La CLI AWS SAM crée un conteneur Docker local et invoque votre fonction. Voici un exemple de résultat :


$ sam local invoke
Invoking app.lambda_handler (python3.9)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-python3.9
Building image.....................
Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.

Mounting /Users/.../Demo/sam-tutorial1/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container
START RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6 Version: $LATEST
END RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6
REPORT RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6    Init Duration: 1.01 ms    Duration: 633.45 ms    Billed Duration: 634 ms    Memory Size: 128 MB    Max Memory Used: 128 MB
{"statusCode": 200, "body": "{\"message\": \"hello world\"}"}

Pour héberger votre API localement

Dans votre ligne de commande, à partir du répertoire du projet sam-app, exécutez ce qui suit :
```
$ sam local start-api
```

La CLI AWS SAM crée un conteneur Docker local pour votre fonction Lambda et crée un serveur HTTP local pour simuler le point de terminaison de votre API. Voici un exemple de résultat :


$ sam local start-api
Initializing the lambda functions containers.
Local image is up-to-date
Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.

Mounting /Users/.../Demo/sam-tutorial1/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container
Containers Initialization is done.
Mounting HelloWorldFunction at http://127.0.0.1:3000/hello [GET]
You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template
2023-03-15 14:25:21 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:3000
2023-03-15 14:25:21 Press CTRL+C to quit

À l'aide de votre navigateur ou de la ligne de commande, envoyez une requête GET au point de terminaison de votre API local. Voici un exemple d'utilisation de la commande curl :
```
$ curl http://127.0.0.1:3000/hello
{"message": "hello world"}
```

Étape 8 : Supprimez votre application du AWS Cloud

Au cours de cette étape, vous devez utiliser la AWS SAMCLI sam delete commande pour supprimer votre application du AWS Cloud.

Pour supprimer votre candidature du AWS Cloud

Dans votre ligne de commande, à partir du répertoire du projet sam-app, exécutez ce qui suit :
```
$ sam delete
```

La CLI AWS SAM vous demandera de confirmer. Ensuite, il supprimera le bucket et la AWS CloudFormation pile Amazon S3 de votre application. Voici un exemple de résultat :


$ sam delete
    Are you sure you want to delete the stack sam-app in the region us-west-2 ? [y/N]: y
    Are you sure you want to delete the folder sam-app in S3 which contains the artifacts? [y/N]: y
    - Deleting S3 object with key c6ce8fa8b5a97dd022ecd006536eb5a4
    - Deleting S3 object with key 5d513a459d062d644f3b7dd0c8b56a2a.template
    - Deleting S3 object with key sam-app/2bebf67c79f6a743cc5312f6dfc1efee.template
    - Deleting S3 object with key sam-app/6b208d0e42ad15d1cee77d967834784b.template
    - Deleting S3 object with key sam-app/da3c598813f1c2151579b73ad788cac8
    - Deleting S3 object with key sam-app/f798cdd93cee188a71d120f14a035b11
    - Deleting Cloudformation stack sam-app

Deleted successfully

Résolution des problèmes

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

En savoir plus

Pour en savoir plus AWS SAM, consultez les ressources suivantes :

The Complete AWS SAM Workshop : atelier destiné à vous enseigner un bon nombre des principales fonctionnalités d' AWS SAM .
Sessions avec SAM — Série de vidéos créée par notre équipe AWS Serverless Developer Advocate sur l'utilisation AWS SAM.
Serverless Land : site qui rassemble les dernières informations, blogs, vidéos, code et ressources d'apprentissage pour AWS sans serveur.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Installation de la CLI AWS SAM

Utiliser AWS SAM