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émarrage rapide : Publication d'applications
Ce guide explique les étapes à suivre pour télécharger, créer, tester et publier un exemple d'application sans serveur sur la AWS SAM CLI AWS Serverless Application Repository d'utilisation. Vous pouvez utiliser cet exemple d'application comme point de départ pour développer et publier votre propre application sans serveur.
## Présentation de
Les étapes suivantes décrivent comment télécharger, créer et publier un exemple d'application sans serveur :
1. **Initialiser**. Téléchargez un exemple d'application à partir du modèle à l'aide de `sam init`.
1. **Testez localement**. Testez l'application localement à l'aide de `sam local invoke` and/or `sam local start-api`. Notez qu'avec ces commandes, même si votre fonction Lambda est invoquée localement, elle lit et écrit dans les AWS ressources du AWS Cloud.
1. **Package**. Lorsque vous êtes satisfait de votre fonction Lambda, regroupez la fonction Lambda, le AWS SAM modèle et toutes les dépendances dans un CloudFormation package de déploiement à l'aide de. `sam package` Dans cette étape, vous allez également inclure des informations sur l'application qui sera téléchargée vers AWS Serverless Application Repository.
1. **Publiez**. Publiez l'application sur AWS Serverless Application Repository en utilisant `sam publish`. À la fin de cette étape, vous pouvez visualiser votre application dans le cloud AWS Serverless Application Repository et la déployer dans le AWS cloud à l'aide de AWS Serverless Application Repository.
L'exemple [Application Hello World](#serverlessrepo-quick-start-hello-world) à la section suivante vous guide à travers ces étapes de création et de publication d'une application sans serveur.
## Application Hello World
Dans cet exercice, vous téléchargez et testez une application Hello World sans serveur qui représente un back-end d'API simple. Il possède un point de terminaison Amazon API Gateway qui prend en charge une opération GET et une fonction Lambda. Lorsqu'une requête GET est envoyée au point de terminaison, API Gateway appelle la fonction Lambda. AWS Lambda Exécute ensuite la fonction, qui renvoie simplement un `hello world` message.
L'application comporte les composants suivants :
+ AWS SAM Modèle qui définit deux AWS ressources pour l'application Hello World : un service API Gateway avec une opération GET et une fonction Lambda. Le modèle définit également le mappage entre l'opération GET d'API Gateway et la fonction Lambda.
+ Code d'application écrit en Python.
## Avant de commencer
Assurez-vous que vous avez la configuration requise pour cet exercice :
+ Vous devez disposer d'un AWS compte auprès d'un utilisateur IAM disposant d'autorisations d'administrateur. Consultez la section [Créer un AWS compte](https://docs.aws.amazon.com/lambda/latest/dg/setup.html).
+ La AWS SAM CLI (interface de ligne de commande) doit être installée. Reportez-vous à la section [Installation de la AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html).
+ La version 1.16.77 ou ultérieure doit être installée. AWS CLI Veuillez consulter [Installation de AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html).
## Étape 1 : Initialiser l'application
Dans cette section, vous téléchargez l'exemple d'application, qui se compose d'un modèle AWS SAM et d'un code d'application.
**Pour initialiser l'application**
1. Exécutez la commande suivante à partir d'une invite de commande de la AWS SAM CLI.
```
sam init --runtime python3.6
```
1. Vérifiez le contenu du répertoire créé par la commande (`sam-app/`) :
+ `template.yaml`— Définit deux AWS ressources dont l'application Hello World a besoin : une fonction Lambda et un point de terminaison API Gateway qui prend en charge une opération GET. Le modèle définit également le mappage entre les deux ressources.
+ Contenu lié au code de l'application Hello World :
+ `hello_world/`répertoire — Contient le code de l'application, qui est renvoyé `hello world` lorsque vous l'exécutez.
**Note**
Pour cet exercice, le code de l'application est écrit en Python et vous spécifiez le runtime dans la `init` commande. AWS Lambda prend en charge des langues supplémentaires pour créer du code d'application. Si vous spécifiez un autre moteur d'exécution pris en charge, la commande `init` fournit le code Hello World dans le langage spécifié et un fichier `README.md` que vous pouvez suivre pour ce langage. Pour de plus amples informations sur les runtimes pris en charge, veuillez consulter [Environnement d'exécution Lambda et bibliothèques disponibles](https://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html).
## Étape 2 : Tester l'application localement
Maintenant que l' AWS SAM application est installée sur votre ordinateur local, suivez les étapes ci-dessous pour la tester localement.
**Pour tester l'application localement**
1. Démarrez le point de terminaison API Gateway localement. Vous devez exécuter la commande suivante à partir du répertoire qui contient le fichier `template.yaml`.
```
sam-app> sam local start-api --region us-east-1
```
La commande renvoie un point de terminaison API Gateway, auquel vous pouvez envoyer des demandes pour des tests locaux.
1. Testez l'application. Copiez l'URL du point de terminaison API Gateway, collez-la dans le navigateur et choisissez **Enter**. Voici un exemple d'URL du point de terminaison API Gateway`http://127.0.0.1:3000/hello`.
API Gateway appelle localement la fonction Lambda à laquelle le point de terminaison est mappé. La fonction Lambda s'exécute dans le conteneur Docker local et revient. `hello world` API Gateway renvoie une réponse au navigateur contenant le texte.
**Exercice : Modifier la chaîne de message**
Après avoir testé avec succès l'exemple d'application, vous pouvez expérimenter avec une simple modification : modifier la chaîne de message renvoyée.
1. Modifiez le fichier `/hello_world/app.py` pour remplacer la chaîne de message `'hello world'` par `'Hello World!'`.
1. Rechargez l'URL de test dans votre navigateur et observez la nouvelle chaîne.
Vous remarquerez que votre nouveau code est chargé dynamiquement, sans que vous ayez redémarré le processus `sam local`.
## Étape 3 : Créer le package de l'application
Après avoir testé votre application localement, vous utilisez la AWS SAM CLI pour créer un package de déploiement et un AWS SAM modèle de package.
**Note**
Au cours des étapes suivantes, vous créez un fichier .zip pour le contenu du répertoire `hello_world/`, qui contient le code de l'application. Ce fichier .zip est le **package de déploiement** de votre application sans serveur. Pour plus d'informations, consultez la section [Création d'un package de déploiement (Python)](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html) dans le *manuel du AWS Lambda développeur*.
**Pour créer un package de déploiement Lambda**
1. Ajoutez une `Metadata` section à votre fichier AWS SAM modèle fournissant les informations de candidature requises. Pour plus d'informations sur la `Metadata` section des AWS SAM modèles, voir [Propriétés de la section des métadonnées des AWS SAM modèles](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications-metadata-properties.html) dans le *Guide du AWS Serverless Application Model développeur*.
Voici un exemple de section `Metadata` :
```
Metadata:
AWS::ServerlessRepo::Application:
Name: my-app
Description: hello world
Author: user1
SpdxLicenseId: Apache-2.0
LicenseUrl: LICENSE.txt
ReadmeUrl: README.md
Labels: ['tests']
HomePageUrl: https://github.com/user1/my-app-project
SemanticVersion: 0.0.1
SourceCodeUrl: https://github.com/user1/my-app-project
```
Les `ReadmeUrl` propriétés `LicenseUrl` et peuvent être des références à des fichiers locaux (comme dans l'exemple ci-dessus) ou des liens vers des compartiments Amazon S3 qui hébergent déjà ces artefacts.
1. Créez un compartiment S3 à l'emplacement où vous souhaitez enregistrer le code empaqueté. Si vous souhaitez utiliser un compartiment S3 existant, ignorez cette étape.
```
sam-app> aws s3 mb s3://bucketname
```
1. Créez le package de déploiement de la fonction Lambda en exécutant la commande `package` AWS SAM CLI suivante.
```
sam-app> sam package \
--template-file template.yaml \
--output-template-file packaged.yaml \
--s3-bucket bucketname
```
La commande exécute les opérations suivantes :
+ Compresse le contenu du `aws-sam/hello_world/` répertoire et le télécharge sur Amazon S3.
+ Télécharge le package de déploiement, le fichier README et le fichier LICENSE dans le compartiment Amazon S3 spécifié par l'`--s3-bucket`option.
+ Affiche un nouveau fichier modèle, appelé `packaged.yaml`, que vous utilisez à l'étape suivante pour publier l'application AWS Serverless Application Repository. Le fichier `packaged.yaml` modèle est similaire au fichier modèle d'origine (`template.yaml`), mais présente une différence essentielle : `CodeUri` les `ReadmeUrl` propriétés et les propriétés pointent vers le compartiment Amazon S3 et les objets contenant les artefacts correspondants. `LicenseUrl` L'extrait suivant d'un exemple de fichier de modèle `packaged.yaml` montre la propriété `CodeUri` :
```
HelloWorldFunction:
Type: AWS::Serverless::Function # For more information about function resources, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Properties:
CodeUri: s3://bucketname/fbd77a3647a4f47a352fcObjectGUID
...
```
## Étape 4 : Publier l'application
Maintenant que vous avez créé le package de déploiement, vous l'utilisez pour publier l'application sur AWS Serverless Application Repository.
**Pour publier l'application sans serveur sur AWS Serverless Application Repository**
+ Exécutez la commande suivante pour publier la nouvelle application AWS Serverless Application Repository avec la première version créée en tant que 0.0.1.
```
sam-app> sam publish \
--template packaged.yaml \
--region us-east-1
```
**Note**
L'application sera créée comme privée par défaut. Vous devez partager l'application pour que AWS les autres comptes soient autorisés à consulter et à déployer votre application. Consultez **Étapes suivantes** ci-dessous pour plus de détails sur le partage de votre application.
## Étapes suivantes
Maintenant que vous avez publié votre exemple d'application, voici comme vous pouvez l'utiliser.
+ **Afficher votre application dans AWS Serverless Application Repository** : le résultat de la `sam publish` commande inclura un lien menant AWS Serverless Application Repository directement à la page détaillée de votre application. Vous pouvez également accéder à la page AWS Serverless Application Repository d'accueil et rechercher votre application.
+ **Partagez votre application** : votre application étant définie comme privée par défaut, elle n'est pas visible pour les autres AWS comptes. Pour partager votre application avec d'autres personnes, vous devez soit la rendre publique, soit autoriser une liste spécifique de AWS comptes. Pour plus d'informations sur le partage de votre application à l'aide de la AWS CLI section[AWS Serverless Application Repository Exemples de politiques d'application](security_iam_resource-based-policy-examples.md). Pour de plus amples informations sur le partage de votre application à l'aide de la console, veuillez consulter [Suppression d'une application](serverlessrepo-how-to-publish.md#share-application).
## En savoir plus
Pour plus d'informations sur la `Metadata` section des AWS SAM modèles `sam package` et des `sam publish` commandes de la AWS SAM CLI, consultez la section [Publication d'applications à l'aide de la AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html) dans le *manuel du AWS Serverless Application Model développeur*.