

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.

# Créez votre application dans AWS SAM
<a name="using-sam-cli-init"></a>

Après avoir terminé [Getting started](serverless-getting-started.md) et lu[Comment utiliser AWS Serverless Application Model (AWS SAM)](chapter-using-sam.md), vous serez prêt à créer un AWS SAM projet dans votre environnement de développement. Votre AWS SAM projet servira de point de départ pour l'écriture de votre application sans serveur. Pour obtenir la liste des options de AWS SAMCLI `sam init` commande, consultez[sam init](sam-cli-command-reference-sam-init.md).

La AWS Serverless Application Model commande Command Line Interface (AWS SAMCLI) `sam init` fournit des options permettant d'initialiser une nouvelle application sans serveur composée des éléments suivants :
+ Un AWS SAM modèle pour définir votre code d'infrastructure.
+ Une structure de dossiers qui organise votre application.
+ Configuration de vos AWS Lambda fonctions.

Pour créer un AWS SAM projet, reportez-vous aux rubriques de ces sections.

**Note**  
`sam init`inclut des modèles de projet pour les fonctions durables dans les environnements d'exécution pris en charge (PythonTypeScript, Java). Ces modèles fournissent le code de démarrage et la configuration nécessaires à la création d'applications sans serveur dynamiques.

**Topics**
+ [

## Initialiser une nouvelle application sans serveur
](#using-sam-cli-init-new)
+ [

## Options pour sam init
](#using-sam-cli-init-options)
+ [

## Résolution des problèmes
](#using-sam-cli-init-troubleshooting)
+ [

## Exemples
](#using-sam-cli-init-examples)
+ [

## En savoir plus
](#using-sam-cli-init-learn)
+ [

## Étapes suivantes
](#w2aac18c11c39)

## Initialiser une nouvelle application sans serveur
<a name="using-sam-cli-init-new"></a>

**Pour initialiser une nouvelle application sans serveur à l'aide de la CLI  AWS SAM**

1. `cd` vers un répertoire de départ.

1. Dans la ligne de commande, exécutez la commande suivante :

   ```
   $ sam init
   ```

1. La CLI  AWS SAM vous guidera à travers un flux interactif pour créer une nouvelle application sans serveur.
**Note**  
Comme indiqué dans[Tutoriel : Déployer une application Hello World avec AWS SAM](serverless-getting-started-hello-world.md), cette commande initialise votre application sans serveur et crée le répertoire de votre projet. Ce répertoire contiendra plusieurs fichiers et dossiers. Le fichier le plus important est`template.yaml`. Il s'agit de votre AWS SAM modèle. Votre version de python doit correspondre à la version de python répertoriée dans le `template.yaml` fichier créé par la **sam init** commande.

### Choisir un modèle de départ
<a name="using-sam-cli-init-new-template"></a>

Un *modèle* se compose des éléments suivants :

1. Un AWS SAM modèle pour votre code d'infrastructure.

1. Un répertoire de départ qui organise les fichiers de votre projet. Par exemple, cela peut inclure :

   1. Une structure pour votre code de fonction Lambda et leurs dépendances.

   1. Un dossier `events` qui contient les événements de test pour les tests locaux.

   1. Un dossier `tests` destiné à faciliter les tests d'unités.

   1. Un fichier `samconfig.toml` pour configurer les paramètres du projet.

   1. Un fichier `ReadMe` et d'autres fichiers de base du projet de départ.

   Voici un exemple de répertoire de projet de départ :

   ```
   sam-app
   ├── 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
   ```

Vous pouvez choisir parmi une liste de *modèles de démarrage rapide AWS * disponibles ou fournir votre propre *emplacement de modèle personnalisé*.

**Pour choisir un modèle de démarrage AWS rapide**

1. Lorsque vous y êtes invité, sélectionnez **modèles de démarrage rapide AWS **.

1. Sélectionnez un modèle de démarrage AWS rapide pour commencer. Voici un exemple :

   ```
   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: 4
   ```

**Pour choisir l'emplacement de votre modèle personnalisé**

1. Lorsque vous y êtes invité, sélectionnez l'**emplacement du modèle personnalisé**.

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

1. La CLI  AWS SAM vous invitera à indiquer l'emplacement du modèle.

   ```
   Template location (git, mercurial, http(s), zip, path):
   ```

   Indiquez l'un des emplacements suivants pour l'archive du fichier .zip de votre modèle :
   + **Référentiel GitHub** : chemin d'accès au fichier .zip de votre référentiel GitHub. Le fichier doit se trouver à la racine de votre référentiel.
   + **Référentiel Mercurial** : chemin d'accès au fichier .zip de votre référentiel Mercurial. Le fichier doit se trouver à la racine de votre référentiel.
   + **Chemin .zip** : chemin HTTPS ou local vers votre fichier .zip.

1. La CLI  AWS SAM initialisera votre application sans serveur à l'aide de votre modèle personnalisé.

### Choisir une exécution
<a name="using-sam-cli-init-new-runtime"></a>

Lorsque vous choisissez un *modèle de démarrage rapide AWS *, la CLI  AWS SAM vous invite à sélectionner une exécution pour vos fonctions Lambda. La liste des options affichées par la CLI  AWS SAM correspond aux exécutions prises en charge nativement par Lambda.
+ Le [runtime](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-runtime) fournit un environnement spécifique au langage qui s’exécute dans un environnement d’exécution.
+ [Lorsqu'il est déployé sur le AWS Cloud, le service Lambda appelle votre fonction dans un environnement d'exécution.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html)

Vous pouvez utiliser n'importe quel autre langage de programmation doté d'une exécution personnalisée. Pour ce faire, vous devez créer manuellement la structure de votre application de départ. Vous pouvez ensuite utiliser `sam init` pour initialiser rapidement votre application en configurant un emplacement de modèle personnalisé.

À partir de votre sélection, la CLI  AWS SAM crée le répertoire de départ pour votre code de fonction Lambda et vos dépendances.

Si Lambda prend en charge plusieurs gestionnaires de dépendances pour votre exécution, vous serez invité à choisir votre gestionnaire de dépendances préféré.

### Choisir un type de package
<a name="using-sam-cli-init-new-package"></a>

Lorsque vous choisissez un *modèle de démarrage rapide AWS *, et une *exécution* laCLI  AWS SAM vous invite à sélectionner un *type de package*. Le type de package détermine la manière dont vos fonctions Lambda sont déployées pour être utilisées avec le service Lambda. Les deux types de packages pris en charge sont les suivants :

1. **Image du conteneur** : contient le système d'exploitation de base, l'exécution, les extensions Lambda, le code de votre application et ses dépendances.

1. **.zip file archive** : contient le code de votre application et ses dépendances.

Pour en savoir plus sur le package de déploiement, consultez [Packages de déploiement Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) dans le *Guide du développeur AWS Lambda *.

Voici un exemple de structure de répertoires d'une application avec une fonction Lambda packagée sous forme d'image de conteneur. AWS SAMCLITélécharge l'image et en crée une `Dockerfile` dans le répertoire de la fonction pour spécifier l'image.

```
sam-app
├── README.md
├── __init__.py
├── events
│   └── event.json
├── hello_world
│   ├── Dockerfile
│   ├── __init__.py
│   ├── app.py
│   └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
    ├── __init__.py
    └── unit
        ├── __init__.py
        └── test_handler.py
```

Voici un exemple de structure de répertoires d'une application avec une fonction packagée sous forme d'archive de fichier .zip.

```
sam-app
├── 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
```

### Configuration du AWS X-Ray suivi
<a name="using-sam-cli-init-new-tracing"></a>

Vous pouvez choisir d'activer le AWS X-Ray suivi. Pour en savoir plus, consultez [Qu'est-ce que c'est AWS X-Ray ?](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) dans le *Guide AWS X-Ray du développeur*.

Si vous l'activez, votre AWS SAM modèle AWS SAMCLI est configuré. Voici un exemple :

```
Globals:
  Function:
    ...
    Tracing: Active
  Api:
    TracingEnabled: True
```

### Configurer la surveillance avec Amazon CloudWatch Application Insights
<a name="using-sam-cli-init-new-insights"></a>

Vous pouvez choisir d'activer la surveillance à l'aide d'Amazon CloudWatch Application Insights. Pour en savoir plus, consultez [Amazon CloudWatch Application Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html) dans le *guide de CloudWatch l'utilisateur Amazon*.

Si vous l'activez, votre AWS SAM modèle AWS SAMCLI est configuré. Voici un exemple :

```
Resources:
  ApplicationResourceGroup:
    Type: AWS::ResourceGroups::Group
    Properties:
      Name:
        Fn::Join:
        - ''
        - - ApplicationInsights-SAM-
          - Ref: AWS::StackName
      ResourceQuery:
        Type: CLOUDFORMATION_STACK_1_0
  ApplicationInsightsMonitoring:
    Type: AWS::ApplicationInsights::Application
    Properties:
      ResourceGroupName:
        Fn::Join:
        - ''
        - - ApplicationInsights-SAM-
          - Ref: AWS::StackName
      AutoConfigurationEnabled: 'true'
    DependsOn: ApplicationResourceGroup
```

### Nommer votre application
<a name="using-sam-cli-init-new-name"></a>

Saisissez un nom pour votre application. La CLI  AWS SAM crée un dossier de niveau supérieur pour votre application sous ce nom.

## Options pour sam init
<a name="using-sam-cli-init-options"></a>

Voici quelques-unes des principales options que vous pouvez utiliser avec la commande `sam init`. Pour obtenir la liste de toutes les options, consultez [sam init](sam-cli-command-reference-sam-init.md).

### Initialiser une application à l'aide d'un emplacement de modèle personnalisé
<a name="using-sam-cli-init-options-location"></a>

Utilisez l'option `--location` et indiquez un emplacement de modèle personnalisé pris en charge. Voici un exemple :

```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```

### Initialiser une application sans le flux interactif
<a name="using-sam-cli-init-options-no-interactive"></a>

Utilisez l'option `--no-interactive` et indiquez vos choix de configuration sur la ligne de commande pour ignorer le flux interactif. Voici un exemple :

```
$ sam init --no-interactive --runtime go1.x --name go-demo --dependency-manager mod --app-template hello-world
```

## Résolution des problèmes
<a name="using-sam-cli-init-troubleshooting"></a>

Pour résoudre le problème AWS SAMCLI, voir[Résolution des problèmes de la CLI AWS SAM](sam-cli-troubleshooting.md).

## Exemples
<a name="using-sam-cli-init-examples"></a>

### Initialiser une nouvelle application sans serveur à l'aide du modèle de démarrage Hello World AWS
<a name="using-sam-cli-init-examples-helloworld"></a>

Pour cet exemple, consultez [Étape 1 : initialisation de l'exemple d'application Hello World](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-init) dans le *didacticiel : déploiement de l'application Hello World*.

### Initialiser une nouvelle application sans serveur avec un emplacement de modèle personnalisé
<a name="using-sam-cli-init-examples-custom"></a>

Vous trouverez ci-dessous des exemples d'ajout d'un emplacement GitHub à votre modèle personnalisé :

```
$ sam init --location gh:aws-samples/cookiecutter-aws-sam-python
$ sam init --location git+sh://git@github.com/aws-samples/cookiecutter-aws-sam-python.git
$ sam init --location hg+ssh://hg@bitbucket.org/repo/template-name
```

Voici un exemple de chemin d'accès à un fichier local :

```
$ sam init --location /path/to/template.zip
```

Voici un exemple de chemin accessible par HTTPS :

```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```

## En savoir plus
<a name="using-sam-cli-init-learn"></a>

Pour en savoir plus sur l'utilisation de la commande `sam init`, reportez-vous à ce qui suit :
+ **[Apprentissage AWS SAM : sam init](https://www.youtube.com/watch?v=9m3R-leD5Xo)** — Série Serverless Land « Learning AWS SAM » surYouTube.
+ **[Structurer des applications sans serveur pour les utiliser avec la CLI  AWS SAM(sessions avec SAM S2E7)](https://www.youtube.com/watch?v=k9IRdgze9fQ)** – sessions avec les séries AWS SAM sur YouTube.

## Étapes suivantes
<a name="w2aac18c11c39"></a>

Maintenant que vous avez créé votre AWS SAM projet, vous êtes prêt à créer votre application. Consultez [Définissez votre infrastructure avec AWS SAM](serverless-authoring.md) les instructions détaillées sur les tâches que vous devez effectuer pour ce faire.