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. # Affectation et référencement de variables dans les règles Guard Affectation et référencement de variables dans les règles Guard Vous pouvez attribuer des variables dans vos fichiers de AWS CloudFormation Guard règles pour stocker les informations auxquelles vous souhaitez faire référence dans vos règles Guard. Guard prend en charge l'attribution de variables en un seul coup. Les variables sont évaluées paresseusement, ce qui signifie que Guard n'évalue les variables que lorsque les règles sont exécutées. **Topics** + [ ## Affectation de variables ](#assigning-variables) + [ ## Référencement de variables ](#referencing-variables) + [ ## Champ d'application variable ](#variable-scope) + [ ## Exemples de variables dans les fichiers de règles Guard ](#variables-examples) ## Affectation de variables Affectation de variables Utilisez le `let` mot clé pour initialiser et attribuer une variable. Il est recommandé d'utiliser Snake Case pour les noms de variables. Les variables peuvent stocker des littéraux statiques ou des propriétés dynamiques résultant de requêtes. Dans l'exemple suivant, la variable `ecs_task_definition_task_role_arn` stocke la valeur de chaîne statique`arn:aws:iam:123456789012:role/my-role-name`. ``` let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-role-name' ``` Dans l'exemple suivant, la variable `ecs_tasks` stocke les résultats d'une requête qui recherche toutes les `AWS::ECS::TaskDefinition` ressources d'un CloudFormation modèle. Vous pouvez faire référence `ecs_tasks` aux informations d'accès relatives à ces ressources lorsque vous rédigez des règles. ``` let ecs_tasks = Resources.*[ Type == 'AWS::ECS::TaskDefinition' ] ``` ## Référencement de variables Référencement de variables Utilisez le `%` préfixe pour référencer une variable. Sur la base de l'exemple de `ecs_task_definition_task_role_arn` variable dans[Affectation de variables](#assigning-variables), vous pouvez faire référence `ecs_task_definition_task_role_arn` dans la `query|value literal` section d'une clause de règle de garde. L'utilisation de cette référence garantit que la valeur spécifiée pour la `TaskDefinitionArn` propriété de toute `AWS::ECS::TaskDefinition` ressource dans un CloudFormation modèle est la valeur de chaîne statique`arn:aws:iam:123456789012:role/my-role-name`. ``` Resources.*.Properties.TaskDefinitionArn == %ecs_task_definition_role_arn ``` Sur la base de la `ecs_tasks` variable exemple in[Affectation de variables](#assigning-variables), vous pouvez faire référence `ecs_tasks` à une requête (par exemple, %ECS\$1Tasks.properties). Guard évalue d'abord la variable, `ecs_tasks` puis utilise les valeurs renvoyées pour parcourir la hiérarchie. Si la variable `ecs_tasks` prend des valeurs autres que des chaînes, Guard génère une erreur. **Note** À l'heure actuelle, Guard ne prend pas en charge le référencement de variables dans les messages d'erreur personnalisés. ## Champ d'application variable Champ d'application variable La portée fait référence à la visibilité des variables définies dans un fichier de règles. Un nom de variable ne peut être utilisé qu'une seule fois dans une portée. Il existe trois niveaux où une variable peut être déclarée, ou trois portées de variables possibles : + **Niveau fichier** — Généralement déclarées en haut du fichier de règles, vous pouvez utiliser des variables de niveau fichier dans toutes les règles du fichier de règles. Ils sont visibles dans l'ensemble du fichier. Dans l'exemple de fichier de règles suivant, les variables `ecs_task_definition_task_role_arn` et B `ecs_task_definition_execution_role_arn` sont initialisées au niveau du fichier. ``` let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-task-role-name' let ecs_task_definition_execution_role_arn = 'arn:aws:iam::123456789012:role/my-execution-role-name' rule check_ecs_task_definition_task_role_arn { Resources.*.Properties.TaskRoleArn == %ecs_task_definition_task_role_arn } rule check_ecs_task_definition_execution_role_arn { Resources.*.Properties.ExecutionRoleArn == %ecs_task_definition_execution_role_arn } ``` + **Niveau règle** — Déclarées dans une règle, les variables au niveau de la règle ne sont visibles que pour cette règle spécifique. Toute référence en dehors de la règle entraîne une erreur. Dans l'exemple de fichier de règles suivant, les variables `ecs_task_definition_task_role_arn` et B `ecs_task_definition_execution_role_arn` sont initialisées au niveau des règles. Ils ne `ecs_task_definition_task_role_arn` peuvent être référencés que dans la règle `check_ecs_task_definition_task_role_arn` nommée. Vous ne pouvez référencer la `ecs_task_definition_execution_role_arn` variable que dans la règle `check_ecs_task_definition_execution_role_arn` nommée. ``` rule check_ecs_task_definition_task_role_arn { let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-task-role-name' Resources.*.Properties.TaskRoleArn == %ecs_task_definition_task_role_arn } rule check_ecs_task_definition_execution_role_arn { let ecs_task_definition_execution_role_arn = 'arn:aws:iam::123456789012:role/my-execution-role-name' Resources.*.Properties.ExecutionRoleArn == %ecs_task_definition_execution_role_arn } ``` + **Niveau bloc** — Déclarées dans un bloc, tel qu'une `when` clause, les variables au niveau du bloc ne sont visibles que pour ce bloc spécifique. Toute référence en dehors du bloc entraîne une erreur. Dans l'exemple de fichier de règles suivant, les variables `ecs_task_definition_task_role_arn` et B `ecs_task_definition_execution_role_arn` sont initialisées au niveau du bloc au sein du `AWS::ECS::TaskDefinition` bloc de type. Vous ne pouvez référencer les `ecs_task_definition_execution_role_arn` variables `ecs_task_definition_task_role_arn` et dans les blocs `AWS::ECS::TaskDefinition` de type que pour leurs règles respectives. ``` rule check_ecs_task_definition_task_role_arn { AWS::ECS::TaskDefinition { let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-task-role-name' Properties.TaskRoleArn == %ecs_task_definition_task_role_arn } } rule check_ecs_task_definition_execution_role_arn { AWS::ECS::TaskDefinition { let ecs_task_definition_execution_role_arn = 'arn:aws:iam::123456789012:role/my-execution-role-name' Properties.ExecutionRoleArn == %ecs_task_definition_execution_role_arn } } ``` ## Exemples de variables dans les fichiers de règles Guard Exemples Les sections suivantes fournissent des exemples d'attribution statique et dynamique de variables. ### Affectation statique Affectation statique Voici un exemple de CloudFormation modèle. ``` Resources: EcsTask: Type: 'AWS::ECS::TaskDefinition' Properties: TaskRoleArn: 'arn:aws:iam::123456789012:role/my-role-name' ``` Sur la base de ce modèle, vous pouvez écrire une règle appelée `check_ecs_task_definition_task_role_arn` qui garantit que la `TaskRoleArn` propriété de toutes les ressources du `AWS::ECS::TaskDefinition` modèle est`arn:aws:iam::123456789012:role/my-role-name`. ``` rule check_ecs_task_definition_task_role_arn { let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-role-name' Resources.*.Properties.TaskRoleArn == %ecs_task_definition_task_role_arn } ``` Dans le cadre de la règle, vous pouvez initialiser une variable appelée `ecs_task_definition_task_role_arn` et lui attribuer la valeur `'arn:aws:iam::123456789012:role/my-role-name'` de chaîne statique. La clause de règle vérifie si la valeur spécifiée pour la `TaskRoleArn` propriété de la `EcsTask` ressource est `arn:aws:iam::123456789012:role/my-role-name` en faisant référence à la `ecs_task_definition_task_role_arn` variable dans la `query|value literal` section. ### Affectation dynamique Affectation dynamique Voici un exemple de CloudFormation modèle. ``` Resources: EcsTask: Type: 'AWS::ECS::TaskDefinition' Properties: TaskRoleArn: 'arn:aws:iam::123456789012:role/my-role-name' ``` Sur la base de ce modèle, vous pouvez initialiser une variable appelée `ecs_tasks` dans le cadre du fichier et lui attribuer la requête`Resources.*[ Type == 'AWS::ECS::TaskDefinition'`. Guard interroge toutes les ressources du modèle de saisie et y stocke les informations les concernant`ecs_tasks`. Vous pouvez également écrire une règle appelée `check_ecs_task_definition_task_role_arn` qui garantit que la `TaskRoleArn` propriété de toutes les ressources du `AWS::ECS::TaskDefinition` modèle est `arn:aws:iam::123456789012:role/my-role-name` ``` let ecs_tasks = Resources.*[ Type == 'AWS::ECS::TaskDefinition' ] rule check_ecs_task_definition_task_role_arn { %ecs_tasks.Properties.TaskRoleArn == 'arn:aws:iam::123456789012:role/my-role-name' } ``` La clause de règle vérifie si la valeur spécifiée pour la `TaskRoleArn` propriété de la `EcsTask` ressource est `arn:aws:iam::123456789012:role/my-role-name` en faisant référence à la `ecs_task_definition_task_role_arn` variable dans la `query` section. ### Application de la configuration des CloudFormation modèles Application de la configuration des CloudFormation modèles Passons en revue un exemple plus complexe de cas d'utilisation en production. Dans cet exemple, nous écrivons des règles Guard pour garantir des contrôles plus stricts sur la façon dont les tâches Amazon ECS sont définies. Voici un exemple de CloudFormation modèle. ``` Resources: EcsTask: Type: 'AWS::ECS::TaskDefinition' Properties: TaskRoleArn: 'Fn::GetAtt': [TaskIamRole, Arn] ExecutionRoleArn: 'Fn::GetAtt': [ExecutionIamRole, Arn] TaskIamRole: Type: 'AWS::IAM::Role' Properties: PermissionsBoundary: 'arn:aws:iam::123456789012:policy/MyExamplePolicy' ExecutionIamRole: Type: 'AWS::IAM::Role' Properties: PermissionsBoundary: 'arn:aws:iam::123456789012:policy/MyExamplePolicy' ``` Sur la base de ce modèle, nous écrivons les règles suivantes pour garantir le respect de ces exigences : + Chaque `AWS::ECS::TaskDefinition` ressource du modèle est associée à la fois à un rôle de tâche et à un rôle d'exécution. + Les rôles de tâches et les rôles d'exécution sont des rôles Gestion des identités et des accès AWS (IAM). + Les rôles sont définis dans le modèle. + La `PermissionsBoundary` propriété est spécifiée pour chaque rôle. ``` # Select all Amazon ECS task definition resources from the template let ecs_tasks = Resources.*[ Type == 'AWS::ECS::TaskDefinition' ] # Select a subset of task definitions whose specified value for the TaskRoleArn property is an Fn::Gett-retrievable attribute let task_role_refs = some %ecs_tasks.Properties.TaskRoleArn.'Fn::GetAtt'[0] # Select a subset of TaskDefinitions whose specified value for the ExecutionRoleArn property is an Fn::Gett-retrievable attribute let execution_role_refs = some %ecs_tasks.Properties.ExecutionRoleArn.'Fn::GetAtt'[0] # Verify requirement #1 rule all_ecs_tasks_must_have_task_end_execution_roles when %ecs_tasks !empty { %ecs_tasks.Properties { TaskRoleArn exists ExecutionRoleArn exists } } # Verify requirements #2 and #3 rule all_roles_are_local_and_type_IAM when all_ecs_tasks_must_have_task_end_execution_roles { let task_iam_references = Resources.%task_role_refs let execution_iam_reference = Resources.%execution_role_refs when %task_iam_references !empty { %task_iam_references.Type == 'AWS::IAM::Role' } when %execution_iam_reference !empty { %execution_iam_reference.Type == 'AWS::IAM::Role' } } # Verify requirement #4 rule check_role_have_permissions_boundary when all_ecs_tasks_must_have_task_end_execution_roles { let task_iam_references = Resources.%task_role_refs let execution_iam_reference = Resources.%execution_role_refs when %task_iam_references !empty { %task_iam_references.Properties.PermissionsBoundary exists } when %execution_iam_reference !empty { %execution_iam_reference.Properties.PermissionsBoundary exists } } ```