

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.

# Référencer des fichiers externes dans Infrastructure Composer
<a name="using-composer-external-files"></a>

Vous pouvez utiliser des fichiers externes avec vos modèles AWS Serverless Application Model (AWS SAM) pour réutiliser le code répété et organiser vos projets. Par exemple, vous pouvez disposer de plusieurs ressources d'API REST Amazon API Gateway décrites par une OpenAPI spécification. Au lieu de répliquer le code de OpenAPI spécification dans votre modèle, vous pouvez créer un fichier externe et le référencer pour chacune de vos ressources.

AWS Infrastructure Composer prend en charge les cas d'utilisation de fichiers externes suivants :
+ REST APIRessources API Gateway définies par des fichiers de OpenAPI spécifications externes.
+ AWS Step Functions ressources de machine d'état définies par des fichiers de définition de machine d'état externes.

Pour en savoir plus sur la configuration de fichiers externes pour les ressources prises en charge, consultez les rubriques suivantes :
+ `[ DefinitionBody](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-api.html#sam-api-definitionbody)` pour `AWS::Serverless::Api`.
+ `[ DefinitionUri](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-statemachine.html#sam-statemachine-definitionuri)` pour `AWS::Serverless::StateMachine`.

**Note**  
Pour référencer des fichiers externes avec Infrastructure Composer depuis la console Infrastructure Composer, vous devez utiliser Infrastructure Composer en mode **synchronisation locale**. Pour de plus amples informations, veuillez consulter [Synchronisez et enregistrez localement votre projet dans la console Infrastructure Composer](using-composer-project-local-sync.md).

**Topics**
+ [

# Bonnes pratiques pour les fichiers de référence externes d'Infrastructure Composer
](using-composer-external-files-best-practices.md)
+ [

# Création d'une référence de fichier externe dans Infrastructure Composer
](using-composer-external-files-new.md)
+ [

# Charger un projet avec une référence de fichier externe dans Infrastructure Composer
](using-composer-external-files-load.md)
+ [

# Création d'une application qui référence un fichier externe dans Infrastructure Composer
](using-composer-external-files-examples-example3.md)
+ [

# Référencez un fichier externe de OpenAPI spécification avec Infrastructure Composer
](using-composer-external-files-examples-example1.md)

# Bonnes pratiques pour les fichiers de référence externes d'Infrastructure Composer
<a name="using-composer-external-files-best-practices"></a>

## Utiliser Infrastructure Composer avec un IDE local
<a name="using-composer-external-files-best-practices-ide"></a>

Lorsque vous utilisez Infrastructure Composer avec un IDE **local en mode de synchronisation locale**, vous pouvez utiliser votre IDE local pour afficher et modifier des fichiers externes. Le contenu des fichiers externes pris en charge qui sont référencés sur votre modèle sera automatiquement mis à jour dans le canevas Infrastructure Composer. Pour en savoir plus, veuillez consulter la section [Connectez la console Infrastructure Composer à votre IDE local](other-services-ide.md).

## Conservez les fichiers externes dans le répertoire parent de votre projet
<a name="using-composer-external-files-best-practices-directory"></a>

Vous pouvez créer des sous-répertoires dans le répertoire parent de votre projet pour organiser vos fichiers externes. Infrastructure Composer ne peut pas accéder aux fichiers externes stockés dans un répertoire en dehors du répertoire parent de votre projet.

## Déployez votre application à l'aide du AWS SAMCLI
<a name="using-composer-external-files-best-practices-sam"></a>

Lorsque vous déployez votre application sur le AWS Cloud, les fichiers externes locaux doivent d'abord être téléchargés vers un emplacement accessible, tel qu'Amazon Simple Storage Service (Amazon S3). Vous pouvez utiliser la AWS SAM CLI pour faciliter automatiquement ce processus. Pour en savoir plus, consultez la section [Télécharger des fichiers locaux lors du déploiement](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/deploy-upload-local-files.html) dans le *Guide du AWS Serverless Application Model développeur*.

# Création d'une référence de fichier externe dans Infrastructure Composer
<a name="using-composer-external-files-new"></a>

Vous pouvez créer une référence de fichier externe à partir du panneau **des propriétés** des ressources prises en charge.

**Pour créer une référence de fichier externe**

1. À partir d'une carte de composant améliorée **API Gateway** ou **Step Functions**, sélectionnez **Details** pour afficher le panneau **des propriétés des ressources**.

1. Recherchez et sélectionnez l'option **Utiliser un fichier externe**.

1. Spécifiez le chemin relatif vers le fichier externe. Il s'agit du chemin de votre `template.yaml` fichier vers le fichier externe.

   Par exemple, pour référencer le fichier `api-spec.yaml` externe à partir de la structure du projet suivant, spécifiez-le `./api-spec.yaml` comme chemin relatif.

   ```
   demo
   ├── api-spec.yaml
   ├── src
   │ └── Function
   │ ├── index.js
   │ └── package.json
   └── template.yaml
   ```
**Note**  
Si le fichier externe et son chemin spécifié n'existent pas, Infrastructure Composer le créera.

1. **Enregistrez** vos modifications.

# Charger un projet avec une référence de fichier externe dans Infrastructure Composer
<a name="using-composer-external-files-load"></a>

Suivez les étapes répertoriées sur cette page pour charger un projet Infrastructure Composer avec une référence de fichier externe.

**Depuis la console Infrastructure Composer**

1. Suivez les étapes répertoriées dans [Importer un modèle de projet existant dans la console Infrastructure Composer](using-composer-project-import-template.md).

1. Confirmez qu'Infrastructure Composer vous invite à vous connecter au dossier racine de votre projet 

Si votre navigateur prend en charge l'API d'accès au système de fichiers, Infrastructure Composer vous demandera de vous connecter au dossier racine de votre projet. Infrastructure Composer ouvrira votre projet en mode de **synchronisation locale** pour prendre en charge votre fichier externe. Si le fichier externe référencé n'est pas pris en charge, vous recevrez un message d'erreur. Pour plus d'informations sur les messages d'erreur, consultez[Résolution des problèmes](ref-troubleshooting.md). 

**Extrait du Toolkit for VS Code**

1. Suivez les étapes répertoriées dans [Accédez à Infrastructure Composer à partir du AWS Toolkit for Visual Studio Code](setting-up-composer-access-ide.md).

1. Ouvrez le modèle que vous souhaitez afficher dans Infrastructure Composer.

Lorsque vous accédez à Infrastructure Composer à partir d'un modèle, Infrastructure Composer détecte automatiquement votre fichier externe. Si le fichier externe référencé n'est pas pris en charge, vous recevrez un message d'erreur. Pour plus d'informations sur les messages d'erreur, consultez[Résolution des problèmes](ref-troubleshooting.md).

# Création d'une application qui référence un fichier externe dans Infrastructure Composer
<a name="using-composer-external-files-examples-example3"></a>

Cet exemple utilise le AWS SAMCLI pour créer une application qui fait référence à un fichier externe pour sa définition de machine à états. Vous chargez ensuite votre projet dans Infrastructure Composer avec votre fichier externe correctement référencé.

**Exemple**

1. Tout d'abord, utilisez la **sam init** commande AWS SAM CLI pour initialiser une nouvelle application nommée`demo`. Pendant le flux interactif, sélectionnez le modèle de démarrage rapide du **flux de travail en plusieurs étapes**.

   ```
   $ 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
           ...
   Template: 2
   
   Which runtime would you like to use?
           1 - dotnet6
           2 - dotnetcore3.1
           ...
           15 - python3.7
           16 - python3.10
           17 - ruby2.7
   Runtime: 16
   
   Based on your selections, the only Package type available is Zip.
   We will proceed to selecting the Package type as Zip.
   
   Based on your selections, the only dependency manager available is pip.
   We will proceed copying the template using pip.
   
   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.10
       Architectures: x86_64
       Dependency Manager: pip
       Application Template: step-functions-sample-app
       Output Directory: .
       Configuration file: demo/samconfig.toml
       
       Next steps can be found in the README file at demo/README.md
   
   ...
   ```

   Cette application fait référence à un fichier externe pour la définition de la machine à états.

   ```
   ...
   Resources:
     StockTradingStateMachine:
       Type: AWS::Serverless::StateMachine
       Properties:
         DefinitionUri: statemachine/stock_trader.asl.json
   ...
   ```

   Le fichier externe se trouve dans le `statemachine` sous-répertoire de notre application.

   ```
   demo
   ├── README.md
   ├── __init__.py
   ├── functions
   │   ├── __init__.py
   │   ├── stock_buyer
   │   ├── stock_checker
   │   └── stock_seller
   ├── samconfig.toml
   ├── statemachine
   │   └── stock_trader.asl.json
   ├── template.yaml
   └── tests
   ```

1. Chargez ensuite votre application dans Infrastructure Composer depuis la console. Sur la page d'**accueil** d'Infrastructure Composer, sélectionnez **Charger un CloudFormation modèle**.

1. Sélectionnez notre dossier de `demo` projet et autorisez l'invite à afficher les fichiers. Sélectionnez notre `template.yaml` fichier, puis sélectionnez **Créer**. Lorsque vous y êtes invité, sélectionnez **Enregistrer les modifications**.  
![\[Le compositeur d'infrastructure ouvre la fenêtre du dossier de projet avec notre dossier de projet sélectionné et le dossier Créer prêt à être sélectionné.\]](http://docs.aws.amazon.com/fr_fr/infrastructure-composer/latest/dg/images/aac_use_ex_15.png)

Infrastructure Composer détecte automatiquement le fichier de définition de la machine d'état externe et le charge. Sélectionnez notre **StockTradingStateMachine**ressource et choisissez **Détails** pour afficher le panneau **des propriétés de la ressource**. Ici, vous pouvez voir qu'Infrastructure Composer s'est automatiquement connecté à notre fichier de définition de machine à états externe.

![\[La vue du canevas d'Infrastructure Composer avec le panneau des propriétés des ressources API Gateway affiché, montrant la configuration du fichier de référence externe.\]](http://docs.aws.amazon.com/fr_fr/infrastructure-composer/latest/dg/images/aac_use_ex_03.png)


Toute modification apportée au fichier de définition de la machine d'état sera automatiquement reflétée dans Infrastructure Composer.

# Référencez un fichier externe de OpenAPI spécification avec Infrastructure Composer
<a name="using-composer-external-files-examples-example1"></a>

Cet exemple utilise Infrastructure Composer depuis la console pour référencer un fichier de OpenAPI spécification externe qui définit une API GatewayREST API.

Créez d'abord un nouveau projet depuis la page d'**accueil** d'Infrastructure Composer.

Activez ensuite la **synchronisation locale** en sélectionnant **Activer la synchronisation locale** **dans le menu**. Créez un nouveau dossier nommé`demo`, autorisez l'invite à afficher les fichiers, puis sélectionnez **Activer**. Lorsque vous y êtes invité, sélectionnez **Enregistrer les modifications**.

![\[La fenêtre de synchronisation locale Infrastructure Composer Activate avec un dossier de projet de démonstration sélectionné et le bouton Activer est prêt à être sélectionné.\]](http://docs.aws.amazon.com/fr_fr/infrastructure-composer/latest/dg/images/aac_use_ex_11.png)


Ensuite, faites glisser une carte Amazon API Gateway sur le canevas. Sélectionnez **Détails** pour afficher le panneau **des propriétés des ressources**.

![\[Une ressource API Gateway sur le canevas avec le panneau des propriétés des ressources ouvert.\]](http://docs.aws.amazon.com/fr_fr/infrastructure-composer/latest/dg/images/aac_use_ex_12.png)


Dans le panneau **des propriétés de la ressource**, configurez les éléments suivants et **enregistrez**.
+ Sélectionnez l'option **Utiliser un fichier externe pour la définition de l'API**.
+ Entrée `./api-spec.yaml` en tant que **chemin relatif vers le fichier externe**

![\[Une fenêtre affichant la case à cocher marquée sous Utiliser un fichier externe pour la définition de l'API et un chemin relatif vers un fichier externe défini.\]](http://docs.aws.amazon.com/fr_fr/infrastructure-composer/latest/dg/images/aac_use_ex_13.png)


Cela crée le répertoire suivant sur notre machine locale :

```
demo
└── api-spec.yaml
```

Vous pouvez maintenant configurer le fichier externe sur notre machine locale. À l'aide de notre IDE, ouvrez le fichier `api-spec.yaml` situé dans le dossier de votre projet. Remplacez son contenu par ce qui suit :

```
openapi: '3.0'
info: {}
paths:
  /:
    get:
      responses: {}
    post:
      x-amazon-apigateway-integration:
        credentials:
          Fn::GetAtt:
            - ApiQueuesendmessageRole
            - Arn
        httpMethod: POST
        type: aws
        uri:
          Fn::Sub: arn:${AWS::Partition}:apigateway:${AWS::Region}:sqs:path/${AWS::AccountId}/${Queue.QueueName}
        requestParameters:
          integration.request.header.Content-Type: '''application/x-www-form-urlencoded'''
        requestTemplates:
          application/json: Action=SendMessage&MessageBody={"data":$input.body}
        responses:
          default:
            statusCode: 200
      responses:
        '200':
          description: 200 response
```

Dans la vue **Modèle** d'Infrastructure Composer, vous pouvez voir qu'Infrastructure Composer a automatiquement mis à jour votre modèle pour référencer le fichier externe.

![\[La vue du modèle Infrastructure Composer montrant le code de votre infrastructure configuré pour référencer le fichier externe.\]](http://docs.aws.amazon.com/fr_fr/infrastructure-composer/latest/dg/images/aac_use_ex_07.png)
