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.

# AWS Service Catalog Contraintes liées aux modèles
<a name="catalogs_constraints_template-constraints"></a>

**Note**  
AWS Service Catalog ne prend pas en charge les contraintes de modèle pour les produits Terraform Open Source ou Terraform Cloud. 

Pour limiter les options qui sont à disposition des utilisateurs finaux lorsqu'ils lancent un produit, vous appliquez des contraintes de modèle. Appliquez des contraintes de modèle pour vous assurer que les utilisateurs finaux peuvent utiliser des produits sans violer les exigences de conformité de votre organisation. Vous appliquez des contraintes de modèle à un produit d'un AWS Service Catalog portefeuille. Un portefeuille doit contenir un ou plusieurs produits pour que vous puissiez définir des contraintes de modèle.

Une contrainte de modèle consiste en une ou plusieurs règles qui limitent les valeurs autorisées pour les paramètres définis dans le CloudFormation modèle sous-jacent du produit. Les paramètres d'un modèle CloudFormation définissent l'ensemble de valeurs que les utilisateurs peuvent spécifier lorsqu'ils créent une pile. Par exemple, un paramètre peut définir les différents types d'instances parmi lesquels les utilisateurs peuvent choisir lors du lancement d'une pile incluant des EC2 instances.

Si l'ensemble de valeurs de paramètre dans un modèle est trop large pour le public cible de votre portefeuille, vous pouvez définir des contraintes de modèle pour limiter les valeurs que les utilisateurs peuvent choisir lors du lancement d'un produit. Par exemple, si les paramètres du modèle incluent des types d' EC2 instance trop grands pour les utilisateurs qui ne doivent utiliser que de petits types d'instance (tels que `t2.micro` ou`t2.small`), vous pouvez ajouter une contrainte de modèle pour limiter les types d'instances que les utilisateurs finaux peuvent choisir. Pour plus d'informations sur les paramètres du CloudFormation modèle, consultez la section [Paramètres](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html) du *guide de CloudFormation l'utilisateur*.

Les contraintes de modèle sont liées au sein d'un portefeuille. Si vous appliquez des contraintes de modèle à un produit dans un portefeuille et si vous ajoutez ensuite le produit à un autre portefeuille, les contraintes ne s'appliquent pas au produit dans le deuxième portefeuille.

Si vous appliquez une contrainte de modèle à un produit qui a déjà été partagé avec des utilisateurs, la contrainte est active immédiatement pour tous les lancements de produit suivants et pour toutes les versions du produit dans le portefeuille.

Vous définissez les règles de contrainte du modèle à l'aide d'un éditeur de règles ou en écrivant les règles sous forme de texte JSON dans la console de l' AWS Service Catalog administrateur. Pour plus d'informations sur les règles, y compris la syntaxe et des exemples, consultez [Règles de contrainte de modèle](reference-template_constraint_rules.md).

Pour tester une contrainte avant sa publication pour des utilisateurs, créez un portefeuille test qui contient les mêmes produits et testez les contraintes avec ce portefeuille.

**Pour appliquer des contraintes de modèle à un produit**

1. Ouvrez la console Service Catalog à l'adresse [https://console.aws.amazon.com/servicecatalog/](https://console.aws.amazon.com/servicecatalog/).

1. Sur la page **Portefeuilles**, choisissez le portefeuille contenant le produit auquel vous souhaitez appliquer une contrainte de modèle. 

1. Développez la section **Contraintes** et choisissez **Ajouter des contraintes**.

1. Dans la fenêtre **Sélectionner le produit et le type**, dans **Produit**, sélectionnez le produit pour lequel vous souhaitez définir les contraintes du modèle. Ensuite, pour **Type de contrainte**, choisissez **Modèle**. Sélectionnez **Continuer**.

1. Sur la page **Générateur de contraintes du modèle**, modifiez les règles de contrainte à l'aide de l'éditeur JSON ou de l'interface du générateur de règles.
   + Pour modifier le code JSON de la règle, choisissez l'onglet **Constraint Text Editor**. Plusieurs exemples sont fournis sur cet onglet pour vous aider à démarrer.

     Pour créer les règles à l'aide d'une interface de création de règles, choisissez l'onglet **Générateur de règles**. Sur cet onglet, vous pouvez choisir n'importe quel paramètre spécifié dans le modèle pour le produit, ainsi que les valeurs autorisées pour ce paramètre. En fonction du type du paramètre, vous spécifiez les valeurs autorisées en choisissant des éléments dans une liste de contrôle, en spécifiant un nombre ou en indiquant un ensemble de valeurs dans une liste séparée par des virgules.

     Lorsque vous avez fini de créer une règle, choisissez **Ajouter une règle**. La règle apparaît dans le tableau de l'onglet **Générateur de règles**. Pour consulter et modifier la sortie JSON, choisissez l'onglet **Constraint Text Editor**.

1. Lorsque vous avez terminé de modifier les règles de votre contrainte, choisissez **Soumettre**. Pour voir la contrainte, rendez-vous sur la page des détails du portefeuille et développez **Contraintes**.

# Règles de contrainte de modèle
<a name="reference-template_constraint_rules"></a>

Les règles qui définissent les contraintes du modèle dans un AWS Service Catalog portefeuille décrivent à quel moment les utilisateurs finaux peuvent utiliser le modèle et quelles valeurs ils peuvent spécifier pour les paramètres déclarés dans le CloudFormation modèle utilisé pour créer le produit qu'ils tentent d'utiliser. Les règles sont utiles pour empêcher les utilisateurs finaux de spécifier par inadvertance une valeur incorrecte. Par exemple, vous pouvez ajouter une règle pour vérifier si les utilisateurs finaux ont spécifié un sous-réseau valide dans un VPC donné ou s'ils ont `m1.small` utilisé des types d'instance pour les environnements de test. CloudFormation utilise des règles pour valider les valeurs des paramètres avant de créer les ressources pour le produit.

Chaque règle se compose de deux propriétés : une condition de règle (facultative) et des assertions (obligatoire). La condition de règle détermine si une règle prend effet. Les assertions décrivent les valeurs que les utilisateurs peuvent spécifier pour un paramètre particulier. Si vous ne définissez pas de condition de règle, les assertions de la règle prennent toujours effet. Pour définir une condition de règle et des assertions, vous utilisez des *fonctions intrinsèques spécifiques aux règles* qui sont des fonctions qui peuvent uniquement être utilisées dans la section `Rules` d'un modèle. Vous pouvez imbriquer des fonctions, mais le résultat final d'une condition de règle ou d'une assertion doit avoir la valeur true (vrai) ou false (faux).

Par exemple, supposons que vous avez déclaré un VPC et un paramètre de sous-réseau dans la section `Parameters`. Vous pouvez créer une règle qui vérifie qu'un sous-réseau donné est dans un VPC particulier. Ainsi, lorsqu'un utilisateur spécifie un VPC, il CloudFormation évalue l'assertion pour vérifier si la valeur du paramètre de sous-réseau se trouve dans ce VPC avant de créer ou de mettre à jour la pile. Si la valeur du paramètre n'est pas valide, échouez CloudFormation immédiatement à créer ou à mettre à jour la pile. Si les utilisateurs ne spécifient pas de VPC, CloudFormation ne vérifie pas la valeur du paramètre du sous-réseau.

## Syntaxe
<a name="template-constraint-rules-syntax"></a>

La section `Rules` d'un modèle se compose du nom de clé `Rules`, suivi d'un seul signe deux points. Toutes les déclarations de règle sont placées entre des accolades. Si vous déclarez plusieurs règles, celles-ci sont séparées par des virgules. Pour chaque règle, vous déclarez un nom logique entre guillemets, suivi d'un signe deux points et d'accolades qui entourent la condition de règle et les assertions.

Une règle peut inclure une propriété `RuleCondition` et doit inclure une propriété `Assertions`. Pour chaque règle, vous ne pouvez définir qu'une seule condition de règle ; vous pouvez définir une ou plusieurs assertions au sein de la propriété `Assertions`. Vous définissez une condition et des assertions de règle à l'aide de fonctions intrinsèques spécifiques aux règles, comme illustré dans le pseudo-modèle suivant :

```
"Rules":{
   "Rule01":{
      "RuleCondition":{
         "Rule-specific intrinsic function"
      },
      "Assertions":[
         {
            "Assert":{
               "Rule-specific intrinsic function"
            },
            "AssertDescription":"Information about this assert"
         },
         {
            "Assert":{
               "Rule-specific intrinsic function"
            },
            "AssertDescription":"Information about this assert"
         }
      ]
   },
   "Rule02":{
      "Assertions":[
         {
            "Assert":{
               "Rule-specific intrinsic function"
            },
            "AssertDescription":"Information about this assert"
         }
      ]
   }
}
```

Le pseudo-modèle montre une section `Rules` contenant deux règles nommées `Rule01` et `Rule02`. `Rule01` inclut une condition de règle et deux assertions. Si la fonction dans la condition de règle a la valeur true, les deux fonctions de chaque assertion sont évaluées et appliquées. Si la condition a la valeur false, la règle ne prend pas effet. `Rule02` prend toujours effet, car il n'y a pas de condition de règle, ce qui signifie qu'une assertion est toujours évaluée et appliquée.

*Pour plus d'informations sur les fonctions intrinsèques spécifiques aux règles permettant de définir les conditions et les assertions des règles, consultez la section [Fonctions des AWS règles](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-rules.html) dans le guide de l'AWS CloudFormation utilisateur.*

## Exemple : Vérification conditionnelle d'une valeur de paramètre
<a name="template-constraint-rules-example"></a>

Les deux règles suivantes vérifient la valeur du paramètre `InstanceType`. En fonction de la valeur du paramètre d'environnement (`test` ou `prod`), l'utilisateur doit spécifier `m1.small` ou `m1.large` pour le paramètre `InstanceType`. Les paramètres `InstanceType` et `Environment` doivent être déclarés dans la section `Parameters` du même modèle.

```
"Rules" : {
  "testInstanceType" : {
    "RuleCondition" : {"Fn::Equals":[{"Ref":"Environment"}, "test"]},
    "Assertions" : [
      {
        "Assert" :  { "Fn::Contains" : [ ["m1.small"], {"Ref" : "InstanceType"} ] },
        "AssertDescription" : "For the test environment, the instance type must be m1.small"
      }
    ]
  },
  "prodInstanceType" : {
    "RuleCondition" : {"Fn::Equals":[{"Ref":"Environment"}, "prod"]},
    "Assertions" : [
      {
        "Assert" :  { "Fn::Contains" : [ ["m1.large"], {"Ref" : "InstanceType"} ] },
        "AssertDescription" : "For the prod environment, the instance type must be m1.large"
      }
    ]
  }
}
```